chunky_png 1.3.11 → 1.3.12

data/lib/chunky_png/canvas/operations.rb

@@ -15,8 +15,8 @@ module ChunkyPNG
       # the current instance intact, use {#grayscale} instead.
       #
       # @return [ChunkyPNG::Canvas] Returns itself, converted to grayscale.
-      # @see {#grayscale}
-      # @see {ChunkyPNG::Color#to_grayscale}
+      # @see #grayscale
+      # @see ChunkyPNG::Color#to_grayscale
       def grayscale!
         pixels.map! { |pixel| ChunkyPNG::Color.to_grayscale(pixel) }
         self
@@ -29,8 +29,8 @@ module ChunkyPNG
       #
       # @return [ChunkyPNG::Canvas] A copy of the canvas, converted to
       #   grayscale.
-      # @see {#grayscale!}
-      # @see {ChunkyPNG::Color#to_grayscale}
+      # @see #grayscale!
+      # @see ChunkyPNG::Color#to_grayscale
       def grayscale
         dup.grayscale!
       end
@@ -56,11 +56,14 @@ module ChunkyPNG
 
         for y in 0...other.height do
           for x in 0...other.width do
-            set_pixel(x + offset_x,
-                      y + offset_y,
-                      ChunkyPNG::Color.compose(other.get_pixel(x, y),
-                                               get_pixel(x + offset_x,
-                                                         y + offset_y)))
+            set_pixel(
+              x + offset_x,
+              y + offset_y,
+              ChunkyPNG::Color.compose(
+                other.get_pixel(x, y),
+                get_pixel(x + offset_x, y + offset_y)
+              )
+            )
           end
         end
         self
@@ -169,17 +172,16 @@ module ChunkyPNG
       #   coordinates are bigger then the original image.
       def crop!(x, y, crop_width, crop_height)
         if crop_width + x > width
-          raise ChunkyPNG::OutOfBounds, 'Original image width is too small!'
+          raise ChunkyPNG::OutOfBounds, "Original image width is too small!"
         end
         if crop_height + y > height
-          raise ChunkyPNG::OutOfBounds, 'Original image height is too small!'
+          raise ChunkyPNG::OutOfBounds, "Original image height is too small!"
         end
 
         if crop_width == width && x == 0
           # We only need to crop off the top and/or bottom, so we can take a
           # shortcut.
-          replace_canvas!(crop_width, crop_height,
-                          pixels.slice(y * width, width * crop_height))
+          replace_canvas!(crop_width, crop_height, pixels.slice(y * width, width * crop_height))
         else
           new_pixels = []
           for cy in 0...crop_height do
@@ -221,8 +223,8 @@ module ChunkyPNG
         self
       end
 
-      alias_method :flip!, :flip_horizontally!
-      alias_method :flip,  :flip_horizontally
+      alias flip! flip_horizontally!
+      alias flip flip_horizontally
 
       # Flips the image vertically, leaving the original intact.
       #
@@ -253,8 +255,8 @@ module ChunkyPNG
         self
       end
 
-      alias_method :mirror!, :flip_vertically!
-      alias_method :mirror,  :flip_vertically
+      alias mirror! flip_vertically!
+      alias mirror flip_vertically
 
       # Returns a new canvas instance that is rotated 90 degrees clockwise.
       #
@@ -278,8 +280,8 @@ module ChunkyPNG
         replace_canvas!(height, width, new_pixels)
       end
 
-      alias_method :rotate_clockwise,  :rotate_right
-      alias_method :rotate_clockwise!, :rotate_right!
+      alias rotate_clockwise rotate_right
+      alias rotate_clockwise! rotate_right!
 
       # Returns an image that is rotated 90 degrees counter-clockwise.
       #
@@ -305,8 +307,8 @@ module ChunkyPNG
         replace_canvas!(height, width, new_pixels)
       end
 
-      alias_method :rotate_counter_clockwise,  :rotate_left
-      alias_method :rotate_counter_clockwise!, :rotate_left!
+      alias rotate_counter_clockwise rotate_left
+      alias rotate_counter_clockwise! rotate_left!
 
       # Rotates the image 180 degrees.
       #
@@ -389,11 +391,11 @@ module ChunkyPNG
       #   applied.
       # @raise [ChunkyPNG::OutOfBounds] when the other image doesn't fit.
       def check_size_constraints!(other, offset_x, offset_y)
-        if width  < other.width  + offset_x
-          raise ChunkyPNG::OutOfBounds, 'Background image width is too small!'
+        if width < other.width + offset_x
+          raise ChunkyPNG::OutOfBounds, "Background image width is too small!"
         end
         if height < other.height + offset_y
-          raise ChunkyPNG::OutOfBounds, 'Background image height is too small!'
+          raise ChunkyPNG::OutOfBounds, "Background image height is too small!"
         end
       end
     end

data/lib/chunky_png/canvas/png_decoding.rb

@@ -1,6 +1,5 @@
 module ChunkyPNG
   class Canvas
-
     # The PNGDecoding contains methods for decoding PNG datastreams to create a
     # Canvas object. The datastream can be provided as filename, string or IO
     # stream.
@@ -28,7 +27,6 @@ module ChunkyPNG
     # @see ChunkyPNG::Canvas::PNGEncoding
     # @see http://www.w3.org/TR/PNG/ The W3C PNG format specification
     module PNGDecoding
-
       # Decodes a Canvas from a PNG encoded string.
       # @param [String] str The string to read from.
       # @return [ChunkyPNG::Canvas] The canvas decoded from the PNG encoded string.
@@ -36,7 +34,7 @@ module ChunkyPNG
         from_datastream(ChunkyPNG::Datastream.from_blob(str))
       end
 
-      alias_method :from_string, :from_blob
+      alias from_string from_blob
 
       # Decodes a Canvas from a PNG encoded file.
       # @param [String] filename The file to read from.
@@ -52,7 +50,7 @@ module ChunkyPNG
         from_datastream(ChunkyPNG::Datastream.from_io(io))
       end
 
-      alias_method :from_stream, :from_io
+      alias from_stream from_io
 
       # Decodes the Canvas from a PNG datastream instance.
       # @param [ChunkyPNG::Datastream] ds The datastream to decode.
@@ -85,7 +83,7 @@ module ChunkyPNG
       # color mode and interlacing mode.
       # @param [String] stream The pixelstream to read from.
       # @param [Integer] width The width of the image.
-      # @param [Integer] width The height of the image.
+      # @param [Integer] height The height of the image.
       # @param [Integer] color_mode The color mode of the encoded pixelstream.
       # @param [Integer] depth The bit depth of the pixel samples.
       # @param [Integer] interlace The interlace method of the encoded pixelstream.
@@ -96,13 +94,13 @@ module ChunkyPNG
         raise ChunkyPNG::ExpectationFailed, "This palette is not suitable for decoding!" if decoding_palette && !decoding_palette.can_decode?
 
         image = case interlace
-          when ChunkyPNG::INTERLACING_NONE;  decode_png_without_interlacing(stream, width, height, color_mode, depth, decoding_palette)
-          when ChunkyPNG::INTERLACING_ADAM7; decode_png_with_adam7_interlacing(stream, width, height, color_mode, depth, decoding_palette)
+          when ChunkyPNG::INTERLACING_NONE  then decode_png_without_interlacing(stream, width, height, color_mode, depth, decoding_palette)
+          when ChunkyPNG::INTERLACING_ADAM7 then decode_png_with_adam7_interlacing(stream, width, height, color_mode, depth, decoding_palette)
           else raise ChunkyPNG::NotSupported, "Don't know how the handle interlacing method #{interlace}!"
         end
 
         image.pixels.map! { |c| c == transparent_color ? ChunkyPNG::Color::TRANSPARENT : c } if transparent_color
-        return image
+        image
       end
 
       protected
@@ -147,7 +145,7 @@ module ChunkyPNG
       #        the value will be modded by 2 to enforce this.
       # @return [Integer] The extracted 4bit value (0..15)
       def decode_png_extract_4bit_value(byte, index)
-        (index & 0x01 == 0) ? ((byte & 0xf0) >> 4) : (byte & 0x0f)
+        index & 0x01 == 0 ? ((byte & 0xf0) >> 4) : (byte & 0x0f)
       end
 
       # Extract 2 consecutive bits from a byte.
@@ -205,7 +203,6 @@ module ChunkyPNG
         value == 0x01 ? 0xff : 0x00
       end
 
-
       # Decodes a scanline of a 1-bit, indexed image into a row of pixels.
       # @param [String] stream The stream to decode from.
       # @param [Integer] pos The position in the stream on which the scanline starts (including the filter byte).
@@ -259,17 +256,21 @@ module ChunkyPNG
       def decode_png_pixels_from_scanline_truecolor_alpha_16bit(stream, pos, width, _decoding_palette)
         pixels = []
         stream.unpack("@#{pos + 1}n#{width * 4}").each_slice(4) do |r, g, b, a|
-          pixels << ChunkyPNG::Color.rgba(decode_png_resample_16bit_value(r), decode_png_resample_16bit_value(g),
-                                          decode_png_resample_16bit_value(b), decode_png_resample_16bit_value(a))
+          pixels << ChunkyPNG::Color.rgba(
+            decode_png_resample_16bit_value(r),
+            decode_png_resample_16bit_value(g),
+            decode_png_resample_16bit_value(b),
+            decode_png_resample_16bit_value(a),
+          )
         end
-        return pixels
+        pixels
       end
 
       # Decodes a scanline of an 8-bit, true color image into a row of pixels.
       # @params (see #decode_png_pixels_from_scanline_indexed_1bit)
       # @return (see #decode_png_pixels_from_scanline_indexed_1bit)
       def decode_png_pixels_from_scanline_truecolor_8bit(stream, pos, width, _decoding_palette)
-        stream.unpack("@#{pos + 1}" << ('NX' * width)).map { |c| c | 0x000000ff }
+        stream.unpack("@#{pos + 1}" << ("NX" * width)).map { |c| c | 0x000000ff }
       end
 
       # Decodes a scanline of a 16-bit, true color image into a row of pixels.
@@ -280,7 +281,7 @@ module ChunkyPNG
         stream.unpack("@#{pos + 1}n#{width * 3}").each_slice(3) do |r, g, b|
           pixels << ChunkyPNG::Color.rgb(decode_png_resample_16bit_value(r), decode_png_resample_16bit_value(g), decode_png_resample_16bit_value(b))
         end
-        return pixels
+        pixels
       end
 
       # Decodes a scanline of an 8-bit, grayscale image with transparency into a row of pixels.
@@ -298,7 +299,7 @@ module ChunkyPNG
         stream.unpack("@#{pos + 1}n#{width * 2}").each_slice(2) do |g, a|
           pixels << ChunkyPNG::Color.grayscale_alpha(decode_png_resample_16bit_value(g), decode_png_resample_16bit_value(a))
         end
-        return pixels
+        pixels
       end
 
       # Decodes a scanline of a 1-bit, grayscale image into a row of pixels.
@@ -353,12 +354,11 @@ module ChunkyPNG
       # @raise [ChunkyPNG::NotSupported] when the color_mode and/or bit depth is not supported.
       def decode_png_pixels_from_scanline_method(color_mode, depth)
         decoder_method = case color_mode
-          when ChunkyPNG::COLOR_TRUECOLOR;       :"decode_png_pixels_from_scanline_truecolor_#{depth}bit"
-          when ChunkyPNG::COLOR_TRUECOLOR_ALPHA; :"decode_png_pixels_from_scanline_truecolor_alpha_#{depth}bit"
-          when ChunkyPNG::COLOR_INDEXED;         :"decode_png_pixels_from_scanline_indexed_#{depth}bit"
-          when ChunkyPNG::COLOR_GRAYSCALE;       :"decode_png_pixels_from_scanline_grayscale_#{depth}bit"
-          when ChunkyPNG::COLOR_GRAYSCALE_ALPHA; :"decode_png_pixels_from_scanline_grayscale_alpha_#{depth}bit"
-          else nil
+          when ChunkyPNG::COLOR_TRUECOLOR       then :"decode_png_pixels_from_scanline_truecolor_#{depth}bit"
+          when ChunkyPNG::COLOR_TRUECOLOR_ALPHA then :"decode_png_pixels_from_scanline_truecolor_alpha_#{depth}bit"
+          when ChunkyPNG::COLOR_INDEXED         then :"decode_png_pixels_from_scanline_indexed_#{depth}bit"
+          when ChunkyPNG::COLOR_GRAYSCALE       then :"decode_png_pixels_from_scanline_grayscale_#{depth}bit"
+          when ChunkyPNG::COLOR_GRAYSCALE_ALPHA then :"decode_png_pixels_from_scanline_grayscale_alpha_#{depth}bit"
         end
 
         raise ChunkyPNG::NotSupported, "No decoder found for color mode #{color_mode} and #{depth}-bit depth!" unless respond_to?(decoder_method, true)
@@ -379,7 +379,6 @@ module ChunkyPNG
       # @param [ChunkyPNG::Palette] decoding_palette The palette to use to decode colors.
       # @return (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream)
       def decode_png_image_pass(stream, width, height, color_mode, depth, start_pos, decoding_palette)
-
         pixels = []
         if width > 0 && height > 0
 
@@ -419,11 +418,11 @@ module ChunkyPNG
       # @return [void]
       def decode_png_str_scanline(stream, pos, prev_pos, line_length, pixel_size)
         case stream.getbyte(pos)
-          when ChunkyPNG::FILTER_NONE;    # noop
-          when ChunkyPNG::FILTER_SUB;     decode_png_str_scanline_sub(     stream, pos, prev_pos, line_length, pixel_size)
-          when ChunkyPNG::FILTER_UP;      decode_png_str_scanline_up(      stream, pos, prev_pos, line_length, pixel_size)
-          when ChunkyPNG::FILTER_AVERAGE; decode_png_str_scanline_average( stream, pos, prev_pos, line_length, pixel_size)
-          when ChunkyPNG::FILTER_PAETH;   decode_png_str_scanline_paeth(   stream, pos, prev_pos, line_length, pixel_size)
+          when ChunkyPNG::FILTER_NONE    then # rubocop:disable Lint/EmptyWhen # no-op
+          when ChunkyPNG::FILTER_SUB     then decode_png_str_scanline_sub(stream, pos, prev_pos, line_length, pixel_size)
+          when ChunkyPNG::FILTER_UP      then decode_png_str_scanline_up(stream, pos, prev_pos, line_length, pixel_size)
+          when ChunkyPNG::FILTER_AVERAGE then decode_png_str_scanline_average(stream, pos, prev_pos, line_length, pixel_size)
+          when ChunkyPNG::FILTER_PAETH   then decode_png_str_scanline_paeth(stream, pos, prev_pos, line_length, pixel_size)
           else raise ChunkyPNG::NotSupported, "Unknown filter type: #{stream.getbyte(pos)}!"
         end
       end
@@ -462,7 +461,7 @@ module ChunkyPNG
       # @return [void]
       def decode_png_str_scanline_average(stream, pos, prev_pos, line_length, pixel_size)
         for i in 1..line_length do
-          a = (i > pixel_size) ? stream.getbyte(pos + i - pixel_size) : 0
+          a = i > pixel_size ? stream.getbyte(pos + i - pixel_size) : 0
           b = prev_pos ? stream.getbyte(prev_pos + i) : 0
           stream.setbyte(pos + i, (stream.getbyte(pos + i) + ((a + b) >> 1)) & 0xff)
         end
@@ -475,14 +474,19 @@ module ChunkyPNG
       def decode_png_str_scanline_paeth(stream, pos, prev_pos, line_length, pixel_size)
         for i in 1..line_length do
           cur_pos = pos + i
-          a = (i > pixel_size) ? stream.getbyte(cur_pos - pixel_size) : 0
+          a = i > pixel_size ? stream.getbyte(cur_pos - pixel_size) : 0
           b = prev_pos ? stream.getbyte(prev_pos + i) : 0
-          c = (prev_pos && i > pixel_size) ? stream.getbyte(prev_pos + i - pixel_size) : 0
+          c = prev_pos && i > pixel_size ? stream.getbyte(prev_pos + i - pixel_size) : 0
           p = a + b - c
           pa = (p - a).abs
           pb = (p - b).abs
           pc = (p - c).abs
-          pr = (pa <= pb) ? (pa <= pc ? a : c) : (pb <= pc ? b : c)
+          pr = if pa <= pb
+            pa <= pc ? a : c
+          else
+            pb <= pc ? b : c
+          end
+
           stream.setbyte(cur_pos, (stream.getbyte(cur_pos) + pr) & 0xff)
         end
       end

data/lib/chunky_png/canvas/png_encoding.rb

@@ -1,17 +1,16 @@
 module ChunkyPNG
   class Canvas
-    
     # Methods for encoding a Canvas instance into a PNG datastream.
     #
     # Overview of the encoding process:
     #
     # * The image is split up in scanlines (i.e. rows of pixels);
     # * All pixels are encoded as a pixelstream, based on the color mode.
-    # * All the pixel bytes in the pixelstream are adjusted using a filtering 
+    # * All the pixel bytes in the pixelstream are adjusted using a filtering
     #   method if one is specified.
     # * Compress the resulting string using deflate compression.
     # * Split compressed data over one or more PNG chunks.
-    # * These chunks should be embedded in a datastream with at least a IHDR and 
+    # * These chunks should be embedded in a datastream with at least a IHDR and
     #   IEND chunk and possibly a PLTE chunk.
     #
     # For interlaced images, the initial image is first split into 7 subimages.
@@ -21,7 +20,6 @@ module ChunkyPNG
     # @see ChunkyPNG::Canvas::PNGDecoding
     # @see http://www.w3.org/TR/PNG/ The W3C PNG format specification
     module PNGEncoding
-
       # The palette used for encoding the image.This is only in used for images
       # that get encoded using indexed colors.
       # @return [ChunkyPNG::Palette]
@@ -40,28 +38,28 @@ module ChunkyPNG
       # @param constraints (see ChunkyPNG::Canvas::PNGEncoding#to_datastream)
       # @return [void]
       def save(filename, constraints = {})
-        File.open(filename, 'wb') { |io| write(io, constraints) }
+        File.open(filename, "wb") { |io| write(io, constraints) }
       end
-      
+
       # Encoded the canvas to a PNG formatted string.
       # @param constraints (see ChunkyPNG::Canvas::PNGEncoding#to_datastream)
       # @return [String] The PNG encoded canvas as string.
       def to_blob(constraints = {})
         to_datastream(constraints).to_blob
       end
-      
-      alias_method :to_string, :to_blob
-      alias_method :to_s, :to_blob
+
+      alias to_string to_blob
+      alias to_s to_blob
 
       # Converts this Canvas to a datastream, so that it can be saved as a PNG image.
       # @param [Hash, Symbol] constraints The constraints to use when encoding the canvas.
-      #    This can either be a hash with different constraints, or a symbol which acts as a 
-      #    preset for some constraints. If no constraints are given, ChunkyPNG will decide  
-      #    for itself how to best create the PNG datastream. 
+      #    This can either be a hash with different constraints, or a symbol which acts as a
+      #    preset for some constraints. If no constraints are given, ChunkyPNG will decide
+      #    for itself how to best create the PNG datastream.
       #    Supported presets are <tt>:fast_rgba</tt> for quickly saving images with transparency,
       #    <tt>:fast_rgb</tt> for quickly saving opaque images, and <tt>:best_compression</tt> to
       #    obtain the smallest possible filesize.
-      # @option constraints [Fixnum] :color_mode The color mode to use. Use one of the 
+      # @option constraints [Fixnum] :color_mode The color mode to use. Use one of the
       #    ChunkyPNG::COLOR_* constants.
       # @option constraints [true, false] :interlace Whether to use interlacing.
       # @option constraints [Fixnum] :compression The compression level for Zlib. This can be a
@@ -75,8 +73,13 @@ module ChunkyPNG
         encoding = determine_png_encoding(constraints)
 
         ds = Datastream.new
-        ds.header_chunk = Chunk::Header.new(:width => width, :height => height,
-            :color => encoding[:color_mode], :depth => encoding[:bit_depth], :interlace => encoding[:interlace])
+        ds.header_chunk = Chunk::Header.new(
+          width: width,
+          height: height,
+          color: encoding[:color_mode],
+          depth: encoding[:bit_depth],
+          interlace: encoding[:interlace]
+        )
 
         if encoding[:color_mode] == ChunkyPNG::COLOR_INDEXED
           ds.palette_chunk      = encoding_palette.to_plte_chunk
@@ -85,43 +88,42 @@ module ChunkyPNG
         data           = encode_png_pixelstream(encoding[:color_mode], encoding[:bit_depth], encoding[:interlace], encoding[:filtering])
         ds.data_chunks = Chunk::ImageData.split_in_chunks(data, encoding[:compression])
         ds.end_chunk   = Chunk::End.new
-        return ds
+        ds
       end
 
       protected
 
-      # Determines the best possible PNG encoding variables for this image, by analyzing 
+      # Determines the best possible PNG encoding variables for this image, by analyzing
       # the colors used for the image.
       #
-      # You can provide constraints for the encoding variables by passing a hash with 
+      # You can provide constraints for the encoding variables by passing a hash with
       # encoding variables to this method.
       #
       # @param [Hash, Symbol] constraints The constraints for the encoding. This can be a
       #    Hash or a preset symbol.
       # @return [Hash] A hash with encoding options for {ChunkyPNG::Canvas::PNGEncoding#to_datastream}
       def determine_png_encoding(constraints = {})
-
         encoding = case constraints
-          when :fast_rgb;         { :color_mode => ChunkyPNG::COLOR_TRUECOLOR, :compression => Zlib::BEST_SPEED }
-          when :fast_rgba;        { :color_mode => ChunkyPNG::COLOR_TRUECOLOR_ALPHA, :compression => Zlib::BEST_SPEED }
-          when :best_compression; { :compression => Zlib::BEST_COMPRESSION, :filtering => ChunkyPNG::FILTER_PAETH }
-          when :good_compression; { :compression => Zlib::BEST_COMPRESSION, :filtering => ChunkyPNG::FILTER_NONE }
-          when :no_compression;   { :compression => Zlib::NO_COMPRESSION }
-          when :black_and_white;  { :color_mode => ChunkyPNG::COLOR_GRAYSCALE, :bit_depth => 1 } 
-          when Hash; constraints
+          when :fast_rgb         then {color_mode: ChunkyPNG::COLOR_TRUECOLOR, compression: Zlib::BEST_SPEED}
+          when :fast_rgba        then {color_mode: ChunkyPNG::COLOR_TRUECOLOR_ALPHA, compression: Zlib::BEST_SPEED}
+          when :best_compression then {compression: Zlib::BEST_COMPRESSION, filtering: ChunkyPNG::FILTER_PAETH}
+          when :good_compression then {compression: Zlib::BEST_COMPRESSION, filtering: ChunkyPNG::FILTER_NONE}
+          when :no_compression   then {compression: Zlib::NO_COMPRESSION}
+          when :black_and_white  then {color_mode: ChunkyPNG::COLOR_GRAYSCALE, bit_depth: 1}
+          when Hash              then constraints
           else raise ChunkyPNG::Exception, "Unknown encoding preset: #{constraints.inspect}"
         end
 
         # Do not create a palette when the encoding is given and does not require a palette.
         if encoding[:color_mode]
           if encoding[:color_mode] == ChunkyPNG::COLOR_INDEXED
-            self.encoding_palette = self.palette
-            encoding[:bit_depth] ||= self.encoding_palette.determine_bit_depth
+            self.encoding_palette = palette
+            encoding[:bit_depth] ||= encoding_palette.determine_bit_depth
           else
             encoding[:bit_depth] ||= 8
           end
         else
-          self.encoding_palette = self.palette
+          self.encoding_palette = palette
           suggested_color_mode, suggested_bit_depth = encoding_palette.best_color_settings
           encoding[:color_mode] ||= suggested_color_mode
           encoding[:bit_depth]  ||= suggested_bit_depth
@@ -131,35 +133,34 @@ module ChunkyPNG
         encoding[:compression] ||= Zlib::DEFAULT_COMPRESSION
 
         encoding[:interlace] = case encoding[:interlace]
-          when nil, false, ChunkyPNG::INTERLACING_NONE; ChunkyPNG::INTERLACING_NONE
-          when true, ChunkyPNG::INTERLACING_ADAM7;      ChunkyPNG::INTERLACING_ADAM7
+          when nil, false then ChunkyPNG::INTERLACING_NONE
+          when true then ChunkyPNG::INTERLACING_ADAM7
           else encoding[:interlace]
         end
 
         encoding[:filtering] ||= case encoding[:compression]
-          when Zlib::BEST_COMPRESSION; ChunkyPNG::FILTER_PAETH
-          when Zlib::NO_COMPRESSION..Zlib::BEST_SPEED; ChunkyPNG::FILTER_NONE
+          when Zlib::BEST_COMPRESSION then ChunkyPNG::FILTER_PAETH
+          when Zlib::NO_COMPRESSION..Zlib::BEST_SPEED then ChunkyPNG::FILTER_NONE
           else ChunkyPNG::FILTER_UP
         end
-        return encoding
+        encoding
       end
-      
-      # Encodes the canvas according to the PNG format specification with a given color 
+
+      # Encodes the canvas according to the PNG format specification with a given color
       # mode, possibly with interlacing.
       # @param [Integer] color_mode The color mode to use for encoding.
       # @param [Integer] bit_depth The bit depth of the image.
       # @param [Integer] interlace The interlacing method to use.
       # @return [String] The PNG encoded canvas as string.
       def encode_png_pixelstream(color_mode = ChunkyPNG::COLOR_TRUECOLOR, bit_depth = 8, interlace = ChunkyPNG::INTERLACING_NONE, filtering = ChunkyPNG::FILTER_NONE)
-
-        if color_mode == ChunkyPNG::COLOR_INDEXED 
+        if color_mode == ChunkyPNG::COLOR_INDEXED
           raise ChunkyPNG::ExpectationFailed, "This palette is not suitable for encoding!" if encoding_palette.nil? || !encoding_palette.can_encode?
           raise ChunkyPNG::ExpectationFailed, "This palette has too many colors!" if encoding_palette.size > (1 << bit_depth)
         end
 
         case interlace
-          when ChunkyPNG::INTERLACING_NONE;  encode_png_image_without_interlacing(color_mode, bit_depth, filtering)
-          when ChunkyPNG::INTERLACING_ADAM7; encode_png_image_with_interlacing(color_mode, bit_depth, filtering)
+          when ChunkyPNG::INTERLACING_NONE  then encode_png_image_without_interlacing(color_mode, bit_depth, filtering)
+          when ChunkyPNG::INTERLACING_ADAM7 then encode_png_image_with_interlacing(color_mode, bit_depth, filtering)
           else raise ChunkyPNG::NotSupported, "Unknown interlacing method: #{interlace}!"
         end
       end
@@ -175,7 +176,7 @@ module ChunkyPNG
         stream
       end
 
-      # Encodes the canvas according to the PNG format specification with a given color 
+      # Encodes the canvas according to the PNG format specification with a given color
       # mode and Adam7 interlacing.
       #
       # This method will split the original canvas in 7 smaller canvases and encode them
@@ -201,42 +202,42 @@ module ChunkyPNG
       # @param [Integer] bit_depth The bit depth of the image.
       # @param [Integer] filtering The filtering method to use.
       def encode_png_image_pass_to_stream(stream, color_mode, bit_depth, filtering)
-
         start_pos  = stream.bytesize
         pixel_size = Color.pixel_bytesize(color_mode)
         line_width = Color.scanline_bytesize(color_mode, bit_depth, width)
-        
+
         # Determine the filter method
         encode_method = encode_png_pixels_to_scanline_method(color_mode, bit_depth)
         filter_method = case filtering
-          when ChunkyPNG::FILTER_SUB;     :encode_png_str_scanline_sub
-          when ChunkyPNG::FILTER_UP;      :encode_png_str_scanline_up
-          when ChunkyPNG::FILTER_AVERAGE; :encode_png_str_scanline_average
-          when ChunkyPNG::FILTER_PAETH;   :encode_png_str_scanline_paeth
-          else nil
+          when ChunkyPNG::FILTER_NONE    then nil
+          when ChunkyPNG::FILTER_SUB     then :encode_png_str_scanline_sub
+          when ChunkyPNG::FILTER_UP      then :encode_png_str_scanline_up
+          when ChunkyPNG::FILTER_AVERAGE then :encode_png_str_scanline_average
+          when ChunkyPNG::FILTER_PAETH   then :encode_png_str_scanline_paeth
+          else raise ArgumentError, "Filtering method #{filtering} is not supported"
         end
-        
+
         0.upto(height - 1) do |y|
           stream << send(encode_method, row(y))
         end
-        
+
         # Now, apply filtering if any
         if filter_method
           (height - 1).downto(0) do |y|
             pos = start_pos + y * (line_width + 1)
-            prev_pos = (y == 0) ? nil : pos - (line_width + 1)
+            prev_pos = y == 0 ? nil : pos - (line_width + 1)
             send(filter_method, stream, pos, prev_pos, line_width, pixel_size)
           end
         end
       end
-      
+
       # Encodes a line of pixels using 8-bit truecolor mode.
       # @param [Array<Integer>] pixels A row of pixels of the original image.
       # @return [String] The encoded scanline as binary string
       def encode_png_pixels_to_scanline_truecolor_8bit(pixels)
-        pixels.pack('x' + ('NX' * width))
+        pixels.pack("x" + ("NX" * width))
       end
-      
+
       # Encodes a line of pixels using 8-bit truecolor alpha mode.
       # @param [Array<Integer>] pixels A row of pixels of the original image.
       # @return [String] The encoded scanline as binary string
@@ -250,50 +251,54 @@ module ChunkyPNG
       def encode_png_pixels_to_scanline_indexed_1bit(pixels)
         chars = []
         pixels.each_slice(8) do |p1, p2, p3, p4, p5, p6, p7, p8|
-          chars << ((encoding_palette.index(p1) << 7) |
-                    (encoding_palette.index(p2) << 6) |
-                    (encoding_palette.index(p3) << 5) |
-                    (encoding_palette.index(p4) << 4) |
-                    (encoding_palette.index(p5) << 3) |
-                    (encoding_palette.index(p6) << 2) |
-                    (encoding_palette.index(p7) << 1) |
-                    (encoding_palette.index(p8)))
+          chars << (
+            (encoding_palette.index(p1) << 7) |
+            (encoding_palette.index(p2) << 6) |
+            (encoding_palette.index(p3) << 5) |
+            (encoding_palette.index(p4) << 4) |
+            (encoding_palette.index(p5) << 3) |
+            (encoding_palette.index(p6) << 2) |
+            (encoding_palette.index(p7) << 1) |
+            encoding_palette.index(p8)
+          )
         end
-        chars.pack('xC*')
+        chars.pack("xC*")
       end
-      
+
       # Encodes a line of pixels using 2-bit indexed mode.
       # @param [Array<Integer>] pixels A row of pixels of the original image.
       # @return [String] The encoded scanline as binary string
       def encode_png_pixels_to_scanline_indexed_2bit(pixels)
         chars = []
         pixels.each_slice(4) do |p1, p2, p3, p4|
-          chars << ((encoding_palette.index(p1) << 6) |
-                    (encoding_palette.index(p2) << 4) |
-                    (encoding_palette.index(p3) << 2) |
-                    (encoding_palette.index(p4)))
+          chars << (
+            (encoding_palette.index(p1) << 6) |
+            (encoding_palette.index(p2) << 4) |
+            (encoding_palette.index(p3) << 2) |
+            encoding_palette.index(p4)
+          )
         end
-        chars.pack('xC*')
+        chars.pack("xC*")
       end
-      
+
       # Encodes a line of pixels using 4-bit indexed mode.
       # @param [Array<Integer>] pixels A row of pixels of the original image.
       # @return [String] The encoded scanline as binary string
       def encode_png_pixels_to_scanline_indexed_4bit(pixels)
         chars = []
         pixels.each_slice(2) do |p1, p2|
-          chars << ((encoding_palette.index(p1) << 4) | (encoding_palette.index(p2)))
+          chars << ((encoding_palette.index(p1) << 4) | encoding_palette.index(p2))
         end
-        chars.pack('xC*')
+        chars.pack("xC*")
       end
-      
+
       # Encodes a line of pixels using 8-bit indexed mode.
       # @param [Array<Integer>] pixels A row of pixels of the original image.
       # @return [String] The encoded scanline as binary string
       def encode_png_pixels_to_scanline_indexed_8bit(pixels)
         pixels.map { |p| encoding_palette.index(p) }.pack("xC#{width}")
       end
-      
+
       # Encodes a line of pixels using 1-bit grayscale mode.
       # @param [Array<Integer>] pixels A row of pixels of the original image.
       # @return [String] The encoded scanline as binary string
@@ -309,9 +314,9 @@ module ChunkyPNG
                     (p7.nil? ? 0 : (p7 & 0x0000ffff) >> 15 << 1) |
                     (p8.nil? ? 0 : (p8 & 0x0000ffff) >> 15))
         end
-        chars.pack('xC*')
+        chars.pack("xC*")
       end
-      
+
       # Encodes a line of pixels using 2-bit grayscale mode.
       # @param [Array<Integer>] pixels A row of pixels of the original image.
       # @return [String] The encoded scanline as binary string
@@ -323,9 +328,9 @@ module ChunkyPNG
                     (p3.nil? ? 0 : (p3 & 0x0000ffff) >> 14 << 2) |
                     (p4.nil? ? 0 : (p4 & 0x0000ffff) >> 14))
         end
-        chars.pack('xC*')
+        chars.pack("xC*")
       end
-      
+
       # Encodes a line of pixels using 2-bit grayscale mode.
       # @param [Array<Integer>] pixels A row of pixels of the original image.
       # @return [String] The encoded scanline as binary string
@@ -334,9 +339,9 @@ module ChunkyPNG
         pixels.each_slice(2) do |p1, p2|
           chars << ((p1.nil? ? 0 : ((p1 & 0x0000ffff) >> 12) << 4) | (p2.nil? ? 0 : ((p2 & 0x0000ffff) >> 12)))
         end
-        chars.pack('xC*')
+        chars.pack("xC*")
       end
-      
+
       # Encodes a line of pixels using 8-bit grayscale mode.
       # @param [Array<Integer>] pixels A row of pixels of the original image.
       # @return [String] The encoded scanline as binary string
@@ -350,8 +355,7 @@ module ChunkyPNG
       def encode_png_pixels_to_scanline_grayscale_alpha_8bit(pixels)
         pixels.pack("xn#{width}")
       end
-      
-      
+
       # Returns the method name to use to decode scanlines into pixels.
       # @param [Integer] color_mode The color mode of the image.
       # @param [Integer] depth The bit depth of the image.
@@ -359,19 +363,16 @@ module ChunkyPNG
       # @raise [ChunkyPNG::NotSupported] when the color_mode and/or bit depth is not supported.
       def encode_png_pixels_to_scanline_method(color_mode, depth)
         encoder_method = case color_mode
-          when ChunkyPNG::COLOR_TRUECOLOR;       :"encode_png_pixels_to_scanline_truecolor_#{depth}bit"
-          when ChunkyPNG::COLOR_TRUECOLOR_ALPHA; :"encode_png_pixels_to_scanline_truecolor_alpha_#{depth}bit"
-          when ChunkyPNG::COLOR_INDEXED;         :"encode_png_pixels_to_scanline_indexed_#{depth}bit"
-          when ChunkyPNG::COLOR_GRAYSCALE;       :"encode_png_pixels_to_scanline_grayscale_#{depth}bit"
-          when ChunkyPNG::COLOR_GRAYSCALE_ALPHA; :"encode_png_pixels_to_scanline_grayscale_alpha_#{depth}bit"
-          else nil
+          when ChunkyPNG::COLOR_TRUECOLOR       then :"encode_png_pixels_to_scanline_truecolor_#{depth}bit"
+          when ChunkyPNG::COLOR_TRUECOLOR_ALPHA then :"encode_png_pixels_to_scanline_truecolor_alpha_#{depth}bit"
+          when ChunkyPNG::COLOR_INDEXED         then :"encode_png_pixels_to_scanline_indexed_#{depth}bit"
+          when ChunkyPNG::COLOR_GRAYSCALE       then :"encode_png_pixels_to_scanline_grayscale_#{depth}bit"
+          when ChunkyPNG::COLOR_GRAYSCALE_ALPHA then :"encode_png_pixels_to_scanline_grayscale_alpha_#{depth}bit"
         end
-        
+
         raise ChunkyPNG::NotSupported, "No encoder found for color mode #{color_mode} and #{depth}-bit depth!" unless respond_to?(encoder_method, true)
         encoder_method
       end
-      
-
 
       # Encodes a scanline of a pixelstream without filtering. This is a no-op.
       # @param [String] stream The pixelstream to work on. This string will be modified.
@@ -391,7 +392,7 @@ module ChunkyPNG
       # @return [void]
       def encode_png_str_scanline_sub(stream, pos, prev_pos, line_width, pixel_size)
         line_width.downto(1) do |i|
-          a = (i > pixel_size) ? stream.getbyte(pos + i - pixel_size) : 0
+          a = i > pixel_size ? stream.getbyte(pos + i - pixel_size) : 0
           stream.setbyte(pos + i, (stream.getbyte(pos + i) - a) & 0xff)
         end
         stream.setbyte(pos, ChunkyPNG::FILTER_SUB)
@@ -407,36 +408,41 @@ module ChunkyPNG
         end
         stream.setbyte(pos, ChunkyPNG::FILTER_UP)
       end
-      
+
       # Encodes a scanline of a pixelstream using AVERAGE filtering. This will modify the stream.
       # @param (see #encode_png_str_scanline_none)
       # @return [void]
       def encode_png_str_scanline_average(stream, pos, prev_pos, line_width, pixel_size)
         line_width.downto(1) do |i|
-          a = (i > pixel_size) ? stream.getbyte(pos + i - pixel_size) : 0
+          a = i > pixel_size ? stream.getbyte(pos + i - pixel_size) : 0
           b = prev_pos ? stream.getbyte(prev_pos + i) : 0
           stream.setbyte(pos + i, (stream.getbyte(pos + i) - ((a + b) >> 1)) & 0xff)
         end
         stream.setbyte(pos, ChunkyPNG::FILTER_AVERAGE)
       end
-      
+
       # Encodes a scanline of a pixelstream using PAETH filtering. This will modify the stream.
       # @param (see #encode_png_str_scanline_none)
       # @return [void]
       def encode_png_str_scanline_paeth(stream, pos, prev_pos, line_width, pixel_size)
         line_width.downto(1) do |i|
-          a = (i > pixel_size) ? stream.getbyte(pos + i - pixel_size) : 0
-          b = (prev_pos) ? stream.getbyte(prev_pos + i) : 0
-          c = (prev_pos && i > pixel_size) ? stream.getbyte(prev_pos + i - pixel_size) : 0
+          a = i > pixel_size ? stream.getbyte(pos + i - pixel_size) : 0
+          b = prev_pos ? stream.getbyte(prev_pos + i) : 0
+          c = prev_pos && i > pixel_size ? stream.getbyte(prev_pos + i - pixel_size) : 0
           p = a + b - c
           pa = (p - a).abs
           pb = (p - b).abs
           pc = (p - c).abs
-          pr = (pa <= pb && pa <= pc) ? a : (pb <= pc ? b : c)
+          pr = if pa <= pb && pa <= pc
+            a
+          else
+            pb <= pc ? b : c
+          end
+
           stream.setbyte(pos + i, (stream.getbyte(pos + i) - pr) & 0xff)
         end
         stream.setbyte(pos, ChunkyPNG::FILTER_PAETH)
-      end      
+      end
     end
   end
 end