chunky_png 1.3.8 → 1.3.13

data/lib/chunky_png/canvas/resampling.rb

@@ -1,10 +1,8 @@
-
-
+# frozen-string-literal: true
 
 module ChunkyPNG
   class Canvas
-    
-    # The ChunkyPNG::Canvas::Resampling module defines methods to perform image resampling to 
+    # The ChunkyPNG::Canvas::Resampling module defines methods to perform image resampling to
     # a {ChunkyPNG::Canvas}.
     #
     # Currently, only the nearest neighbor algorithm is implemented. Bilinear and cubic
@@ -12,22 +10,21 @@ module ChunkyPNG
     #
     # @see ChunkyPNG::Canvas
     module Resampling
-
       # Integer Interpolation between two values
       #
       # Used for generating indicies for interpolation (eg, nearest
       # neighbour).
       #
-      # @param [Integer] width The width of the source 
+      # @param [Integer] width The width of the source
       # @param [Integer] new_width The width of the destination
       # @return [Array<Integer>] An Array of Integer indicies
       def steps(width, new_width)
         indicies, residues = steps_residues(width, new_width)
-        
+
         for i in 1..new_width
-          indicies[i-1] = (indicies[i-1] + (residues[i-1] + 127)/255)
+          indicies[i - 1] = (indicies[i - 1] + (residues[i - 1] + 127) / 255)
         end
-        return indicies
+        indicies
       end
 
       # Fractional Interpolation between two values
@@ -39,9 +36,9 @@ module ChunkyPNG
       # @param [Integer] new_width The width of the destination
       # @return [Array<Integer>, Array<Integer>] Two arrays of indicies and residues
       def steps_residues(width, new_width)
-        indicies = Array.new(new_width, obj=nil)
-        residues = Array.new(new_width, obj=nil)
-        
+        indicies = Array.new(new_width, nil)
+        residues = Array.new(new_width, nil)
+
         # This works by accumulating the fractional error and
         # overflowing when necessary.
 
@@ -49,15 +46,15 @@ module ChunkyPNG
         # 2 * new_width
         base_step = width / new_width
         err_step = (width % new_width) << 1
-        denominator = (new_width) << 1
-                
+        denominator = new_width << 1
+
         # Initial pixel
         index = (width - new_width) / denominator
         err = (width - new_width) % denominator
 
         for i in 1..new_width
-          indicies[i-1] = index
-          residues[i-1] = (255.0 * err.to_f / denominator.to_f).round
+          indicies[i - 1] = index
+          residues[i - 1] = (255.0 * err.to_f / denominator.to_f).round
 
           index += base_step
           err += err_step
@@ -67,10 +64,9 @@ module ChunkyPNG
           end
         end
 
-        return indicies, residues
+        [indicies, residues]
       end
 
-      
       # Resamples the canvas using nearest neighbor interpolation.
       # @param [Integer] new_width The width of the resampled canvas.
       # @param [Integer] new_height The height of the resampled canvas.
@@ -79,8 +75,7 @@ module ChunkyPNG
         steps_x = steps(width, new_width)
         steps_y = steps(height, new_height)
 
-
-        pixels = Array.new(new_width*new_height)
+        pixels = Array.new(new_width * new_height)
         i = 0
         for y in steps_y
           for x in steps_x
@@ -88,10 +83,10 @@ module ChunkyPNG
             i += 1
           end
         end
-        
+
         replace_canvas!(new_width.to_i, new_height.to_i, pixels)
       end
-      
+
       def resample_nearest_neighbor(new_width, new_height)
         dup.resample_nearest_neighbor!(new_width, new_height)
       end
@@ -104,19 +99,19 @@ module ChunkyPNG
         index_x, interp_x = steps_residues(width, new_width)
         index_y, interp_y = steps_residues(height, new_height)
 
-        pixels = Array.new(new_width*new_height)
+        pixels = Array.new(new_width * new_height)
         i = 0
         for y in 1..new_height
           # Clamp the indicies to the edges of the image
-          y1 = [index_y[y-1], 0].max
-          y2 = [index_y[y-1] + 1, height - 1].min
-          y_residue = interp_y[y-1]
+          y1 = [index_y[y - 1], 0].max
+          y2 = [index_y[y - 1] + 1, height - 1].min
+          y_residue = interp_y[y - 1]
 
           for x in 1..new_width
             # Clamp the indicies to the edges of the image
-            x1 = [index_x[x-1], 0].max
-            x2 = [index_x[x-1] + 1, width - 1].min
-            x_residue = interp_x[x-1]
+            x1 = [index_x[x - 1], 0].max
+            x2 = [index_x[x - 1] + 1, width - 1].min
+            x_residue = interp_x[x - 1]
 
             pixel_11 = get_pixel(x1, y1)
             pixel_21 = get_pixel(x2, y1)
@@ -139,9 +134,9 @@ module ChunkyPNG
       def resample_bilinear(new_width, new_height)
         dup.resample_bilinear!(new_width, new_height)
       end
-      
-      alias_method :resample, :resample_nearest_neighbor
-      alias_method :resize, :resample
+
+      alias resample resample_nearest_neighbor
+      alias resize resample
     end
   end
 end

data/lib/chunky_png/canvas/stream_exporting.rb

@@ -1,9 +1,9 @@
+# frozen-string-literal: true
+
 module ChunkyPNG
   class Canvas
-
     # Methods to save load a canvas from to stream, encoded in RGB, RGBA, BGR or ABGR format.
     module StreamExporting
-
       # Creates an RGB-formatted pixelstream with the pixel data from this canvas.
       #
       # Note that this format is fast but bloated, because no compression is used
@@ -12,7 +12,7 @@ module ChunkyPNG
       #
       # @return [String] The RGBA-formatted pixel data.
       def to_rgba_stream
-        pixels.pack('N*')
+        pixels.pack("N*")
       end
 
       # Creates an RGB-formatted pixelstream with the pixel data from this canvas.
@@ -23,14 +23,14 @@ module ChunkyPNG
       #
       # @return [String] The RGB-formatted pixel data.
       def to_rgb_stream
-        pixels.pack('NX' * pixels.length)
+        pixels.pack("NX" * pixels.length)
       end
-      
+
       # Creates a stream of the alpha channel of this canvas.
       #
       # @return [String] The 0-255 alpha values of all pixels packed as string
       def to_alpha_channel_stream
-        pixels.pack('C*')
+        pixels.pack("C*")
       end
 
       # Creates a grayscale stream of this canvas.
@@ -40,7 +40,7 @@ module ChunkyPNG
       #
       # @return [String] The 0-255 grayscale values of all pixels packed as string.
       def to_grayscale_stream
-        pixels.pack('nX' * pixels.length)
+        pixels.pack("nX" * pixels.length)
       end
 
       # Creates an ABGR-formatted pixelstream with the pixel data from this canvas.
@@ -51,7 +51,7 @@ module ChunkyPNG
       #
       # @return [String] The RGBA-formatted pixel data.
       def to_abgr_stream
-        pixels.pack('V*')
+        pixels.pack("V*")
       end
     end
   end

data/lib/chunky_png/canvas/stream_importing.rb

@@ -1,9 +1,9 @@
+# frozen-string-literal: true
+
 module ChunkyPNG
   class Canvas
-
     # Methods to quickly load a canvas from a stream, encoded in RGB, RGBA, BGR or ABGR format.
     module StreamImporting
-
       # Creates a canvas by reading pixels from an RGB formatted stream with a
       # provided with and height.
       #
@@ -18,9 +18,9 @@ module ChunkyPNG
       def from_rgb_stream(width, height, stream)
         string = stream.respond_to?(:read) ? stream.read(3 * width * height) : stream.to_s[0, 3 * width * height]
         string << ChunkyPNG::EXTRA_BYTE # Add a fourth byte to the last RGB triple.
-        unpacker = 'NX' * (width * height)
+        unpacker = "NX" * (width * height)
         pixels = string.unpack(unpacker).map { |color| color | 0x000000ff }
-        self.new(width, height, pixels)
+        new(width, height, pixels)
       end
 
       # Creates a canvas by reading pixels from an RGBA formatted stream with a
@@ -36,7 +36,7 @@ module ChunkyPNG
       # @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
       def from_rgba_stream(width, height, stream)
         string = stream.respond_to?(:read) ? stream.read(4 * width * height) : stream.to_s[0, 4 * width * height]
-        self.new(width, height, string.unpack("N*"))
+        new(width, height, string.unpack("N*"))
       end
 
       # Creates a canvas by reading pixels from an BGR formatted stream with a
@@ -53,8 +53,8 @@ module ChunkyPNG
       def from_bgr_stream(width, height, stream)
         string = ChunkyPNG::EXTRA_BYTE.dup # Add a first byte to the first BGR triple.
         string << (stream.respond_to?(:read) ? stream.read(3 * width * height) : stream.to_s[0, 3 * width * height])
-        pixels = string.unpack("@1" << ('XV' * (width * height))).map { |color| color | 0x000000ff }
-        self.new(width, height, pixels)
+        pixels = string.unpack("@1#{"XV" * (width * height)}").map { |color| color | 0x000000ff }
+        new(width, height, pixels)
       end
 
       # Creates a canvas by reading pixels from an ARGB formatted stream with a
@@ -70,7 +70,7 @@ module ChunkyPNG
       # @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
       def from_abgr_stream(width, height, stream)
         string = stream.respond_to?(:read) ? stream.read(4 * width * height) : stream.to_s[0, 4 * width * height]
-        self.new(width, height, string.unpack("V*"))
+        new(width, height, string.unpack("V*"))
       end
     end
   end

data/lib/chunky_png/chunk.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module ChunkyPNG
   # A PNG datastream consists of multiple chunks. This module, and the classes
   # contained within, help with handling these chunks. It supports both reading
@@ -16,10 +18,10 @@ module ChunkyPNG
     # @param io [IO, #read] The IO stream to read from.
     # @return [ChunkyPNG::Chung::Base] The loaded chunk instance.
     def self.read(io)
-      length, type = read_bytes(io, 8).unpack('Na4')
+      length, type = read_bytes(io, 8).unpack("Na4")
 
       content = read_bytes(io, length)
-      crc     = read_bytes(io, 4).unpack('N').first
+      crc     = read_bytes(io, 4).unpack("N").first
       verify_crc!(type, content, crc)
 
       CHUNK_TYPES.fetch(type, Generic).read(type, content)
@@ -74,8 +76,8 @@ module ChunkyPNG
       # @param io [IO] The IO stream to write to.
       # @param content [String] The content for this chunk.
       def write_with_crc(io, content)
-        io << [content.length].pack('N') << type << content
-        io << [Zlib.crc32(content, Zlib.crc32(type))].pack('N')
+        io << [content.length].pack("N") << type << content
+        io << [Zlib.crc32(content, Zlib.crc32(type))].pack("N")
       end
 
       # Writes the chunk to the IO stream.
@@ -84,7 +86,7 @@ module ChunkyPNG
       # and will calculate and append the checksum automatically.
       # @param io [IO] The IO stream to write to.
       def write(io)
-        write_with_crc(io, content || '')
+        write_with_crc(io, content || "")
       end
     end
 
@@ -95,8 +97,8 @@ module ChunkyPNG
       # written by the +write+ method.
       attr_accessor :content
 
-      def initialize(type, content = '')
-        super(type, :content => content)
+      def initialize(type, content = "")
+        super(type, content: content)
       end
 
       # Creates an instance, given the chunk's type and content.
@@ -118,11 +120,10 @@ module ChunkyPNG
     # Note that it is still possible to access the chunk for such an image, but
     # ChunkyPNG will raise an exception if you try to access the pixel data.
     class Header < Base
-      attr_accessor :width, :height, :depth, :color, :compression, :filtering,
-                    :interlace
+      attr_accessor :width, :height, :depth, :color, :compression, :filtering, :interlace
 
       def initialize(attrs = {})
-        super('IHDR', attrs)
+        super("IHDR", attrs)
         @depth       ||= 8
         @color       ||= ChunkyPNG::COLOR_TRUECOLOR
         @compression ||= ChunkyPNG::COMPRESSION_DEFAULT
@@ -137,31 +138,39 @@ module ChunkyPNG
       # @return [ChunkyPNG::Chunk::End] The new Header chunk instance with the
       #   variables set to the values according to the content.
       def self.read(type, content)
-        fields = content.unpack('NNC5')
-        new(:width => fields[0],
-            :height => fields[1],
-            :depth => fields[2],
-            :color => fields[3],
-            :compression => fields[4],
-            :filtering => fields[5],
-            :interlace => fields[6])
+        fields = content.unpack("NNC5")
+        new(
+          width: fields[0],
+          height: fields[1],
+          depth: fields[2],
+          color: fields[3],
+          compression: fields[4],
+          filtering: fields[5],
+          interlace: fields[6]
+        )
       end
 
       # Returns the content for this chunk when it gets written to a file, by
       # packing the image information variables into the correct format.
       # @return [String] The 13-byte content for the header chunk.
       def content
-        [width, height, depth, color, compression, filtering, interlace].
-          pack('NNC5')
+        [
+          width,
+          height,
+          depth,
+          color,
+          compression,
+          filtering,
+          interlace,
+        ].pack("NNC5")
       end
     end
 
     # The End (IEND) chunk indicates the last chunk of a PNG stream. It does
     # not contain any data.
     class End < Base
-
       def initialize
-        super('IEND')
+        super("IEND")
       end
 
       # Reads the END chunk. It will check if the content is empty.
@@ -170,16 +179,16 @@ module ChunkyPNG
       # @param content [String] The content read from the chunk. Should be
       #   empty.
       # @return [ChunkyPNG::Chunk::End] The new End chunk instance.
-      # @raise [RuntimeError] Raises an exception if the content was not empty.
+      # @raise [ChunkyPNG::ExpectationFailed] Raises an exception if the content was not empty.
       def self.read(type, content)
-        raise ExpectationFailed, 'The IEND chunk should be empty!' if content.bytesize > 0
-        self.new
+        raise ExpectationFailed, "The IEND chunk should be empty!" if content.bytesize > 0
+        new
       end
 
       # Returns an empty string, because this chunk should always be empty.
       # @return [""] An empty string.
       def content
-        ChunkyPNG::Datastream.empty_bytearray
+        "".b
       end
     end
 
@@ -214,7 +223,7 @@ module ChunkyPNG
       # @return [Array<Integer>] Returns an array of alpha channel values
       #   [0-255].
       def palette_alpha_channel
-        content.unpack('C*')
+        content.unpack("C*")
       end
 
       # Returns the truecolor entry to be replaced by transparent pixels,
@@ -224,9 +233,8 @@ module ChunkyPNG
       #
       # @return [Integer] The color to replace with fully transparent pixels.
       def truecolor_entry(bit_depth)
-        values = content.unpack('nnn').map do |c|
-          ChunkyPNG::Canvas.send(:"decode_png_resample_#{bit_depth}bit_value", c)
-        end
+        decode_method_name = :"decode_png_resample_#{bit_depth}bit_value"
+        values = content.unpack("nnn").map { |c| ChunkyPNG::Canvas.send(decode_method_name, c) }
         ChunkyPNG::Color.rgb(*values)
       end
 
@@ -238,7 +246,7 @@ module ChunkyPNG
       # @return [Integer] The (grayscale) color to replace with fully
       #   transparent pixels.
       def grayscale_entry(bit_depth)
-        value = ChunkyPNG::Canvas.send(:"decode_png_resample_#{bit_depth}bit_value", content.unpack('n')[0])
+        value = ChunkyPNG::Canvas.send(:"decode_png_resample_#{bit_depth}bit_value", content.unpack("n")[0])
         ChunkyPNG::Color.grayscale(value)
       end
     end
@@ -255,7 +263,7 @@ module ChunkyPNG
       def self.split_in_chunks(data, level = Zlib::DEFAULT_COMPRESSION, chunk_size = 2147483647)
         streamdata = Zlib::Deflate.deflate(data, level)
         # TODO: Split long streamdata over multiple chunks
-        [ ChunkyPNG::Chunk::ImageData.new('IDAT', streamdata) ]
+        [ChunkyPNG::Chunk::ImageData.new("IDAT", streamdata)]
       end
     end
 
@@ -271,12 +279,12 @@ module ChunkyPNG
       attr_accessor :keyword, :value
 
       def initialize(keyword, value)
-        super('tEXt')
+        super("tEXt")
         @keyword, @value = keyword, value
       end
 
       def self.read(type, content)
-        keyword, value = content.unpack('Z*a*')
+        keyword, value = content.unpack("Z*a*")
         new(keyword, value)
       end
 
@@ -285,7 +293,7 @@ module ChunkyPNG
       #
       # @return The content that should be written to the datastream.
       def content
-        [keyword, value].pack('Z*a*')
+        [keyword, value].pack("Z*a*")
       end
     end
 
@@ -299,12 +307,12 @@ module ChunkyPNG
       attr_accessor :keyword, :value
 
       def initialize(keyword, value)
-        super('zTXt')
+        super("zTXt")
         @keyword, @value = keyword, value
       end
 
       def self.read(type, content)
-        keyword, compression, value = content.unpack('Z*Ca*')
+        keyword, compression, value = content.unpack("Z*Ca*")
         raise ChunkyPNG::NotSupported, "Compression method #{compression.inspect} not supported!" unless compression == ChunkyPNG::COMPRESSION_DEFAULT
         new(keyword, Zlib::Inflate.inflate(value))
       end
@@ -314,8 +322,11 @@ module ChunkyPNG
       #
       # @return The content that should be written to the datastream.
       def content
-        [keyword, ChunkyPNG::COMPRESSION_DEFAULT, Zlib::Deflate.deflate(value)].
-          pack('Z*Ca*')
+        [
+          keyword,
+          ChunkyPNG::COMPRESSION_DEFAULT,
+          Zlib::Deflate.deflate(value),
+        ].pack("Z*Ca*")
       end
     end
 
@@ -323,58 +334,96 @@ module ChunkyPNG
     # ratio for display of the image.
     #
     # http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html#C.pHYs
-    #
-    class Physical < Generic
+    class Physical < Base
       attr_accessor :ppux, :ppuy, :unit
 
       def initialize(ppux, ppuy, unit = :unknown)
-        raise ArgumentError, 'unit must be either :meters or :unknown' unless [:meters, :unknown].member?(unit)
-        super('pHYs')
+        raise ArgumentError, "unit must be either :meters or :unknown" unless [:meters, :unknown].member?(unit)
+        super("pHYs")
         @ppux, @ppuy, @unit = ppux, ppuy, unit
       end
 
       def dpix
-        raise ChunkyPNG::UnitsUnknown, 'the PNG specifies its physical aspect ratio, but does not specify the units of its pixels\' physical dimensions' unless unit == :meters
+        raise ChunkyPNG::UnitsUnknown, "the PNG specifies its physical aspect ratio, but does not specify the units of its pixels' physical dimensions" unless unit == :meters
         ppux * INCHES_PER_METER
       end
 
       def dpiy
-        raise ChunkyPNG::UnitsUnknown, 'the PNG specifies its physical aspect ratio, but does not specify the units of its pixels\' physical dimensions' unless unit == :meters
+        raise ChunkyPNG::UnitsUnknown, "the PNG specifies its physical aspect ratio, but does not specify the units of its pixels' physical dimensions" unless unit == :meters
         ppuy * INCHES_PER_METER
       end
 
       def self.read(type, content)
-        ppux, ppuy, unit = content.unpack('NNC')
+        ppux, ppuy, unit = content.unpack("NNC")
         unit = unit == 1 ? :meters : :unknown
         new(ppux, ppuy, unit)
       end
 
-      # Creates the content to write to the stream, by concatenating the
-      # keyword with the deflated value, joined by a null character.
-      #
-      # @return The content that should be written to the datastream.
+      # Assembles the content to write to the stream for this chunk.
+      # @return [String] The binary content that should be written to the datastream.
       def content
-        [ppux, ppuy, unit == :meters ? 1 : 0].pack('NNC')
+        [ppux, ppuy, unit == :meters ? 1 : 0].pack("NNC")
       end
 
       INCHES_PER_METER = 0.0254
     end
 
-    # The Text (iTXt) chunk contains keyword/value metadata about the PNG
-    # stream.
+    # The InternationalText (iTXt) chunk contains keyword/value metadata about the PNG
+    # stream, translated to a given locale.
     #
     # The metadata in this chunk can be encoded using UTF-8 characters.
     # Moreover, it is possible to define the language of the metadata, and give
     # a translation of the keyword name. Finally, it supports bot compressed
     # and uncompressed values.
     #
-    # @todo This chunk is currently not implemented, but merely read and
-    #   written back intact.
+    # http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html#C.iTXt
     #
     # @see ChunkyPNG::Chunk::Text
     # @see ChunkyPNG::Chunk::CompressedText
-    class InternationalText < Generic
-      # TODO
+    class InternationalText < Base
+      attr_accessor :keyword, :text, :language_tag, :translated_keyword, :compressed, :compression
+
+      def initialize(keyword, text, language_tag = "", translated_keyword = "", compressed = ChunkyPNG::UNCOMPRESSED_CONTENT, compression = ChunkyPNG::COMPRESSION_DEFAULT)
+        super("iTXt")
+        @keyword = keyword
+        @text = text
+        @language_tag = language_tag
+        @translated_keyword = translated_keyword
+        @compressed = compressed
+        @compression = compression
+      end
+
+      # Reads the tTXt chunk.
+      # @param type [String] The four character chunk type indicator (= "iTXt").
+      # @param content [String] The content read from the chunk.
+      # @return [ChunkyPNG::Chunk::InternationalText] The new End chunk instance.
+      # @raise [ChunkyPNG::InvalidUTF8] If the chunk contains data that is not UTF8-encoded text.
+      # @raise [ChunkyPNG::NotSupported] If the chunk refers to an unsupported compression method.
+      #  Currently uncompressed data and deflate are supported.
+      def self.read(type, content)
+        keyword, compressed, compression, language_tag, translated_keyword, text = content.unpack("Z*CCZ*Z*a*")
+        raise ChunkyPNG::NotSupported, "Compression flag #{compressed.inspect} not supported!" unless compressed == ChunkyPNG::UNCOMPRESSED_CONTENT || compressed == ChunkyPNG::COMPRESSED_CONTENT
+        raise ChunkyPNG::NotSupported, "Compression method #{compression.inspect} not supported!" unless compression == ChunkyPNG::COMPRESSION_DEFAULT
+
+        text = Zlib::Inflate.inflate(text) if compressed == ChunkyPNG::COMPRESSED_CONTENT
+
+        text.force_encoding("utf-8")
+        raise ChunkyPNG::InvalidUTF8, "Invalid unicode encountered in iTXt chunk" unless text.valid_encoding?
+
+        translated_keyword.force_encoding("utf-8")
+        raise ChunkyPNG::InvalidUTF8, "Invalid unicode encountered in iTXt chunk" unless translated_keyword.valid_encoding?
+
+        new(keyword, text, language_tag, translated_keyword, compressed, compression)
+      end
+
+      # Assembles the content to write to the stream for this chunk.
+      # @return [String] The binary content that should be written to the datastream.
+      def content
+        text_field = text.encode("utf-8")
+        text_field = compressed == ChunkyPNG::COMPRESSED_CONTENT ? Zlib::Deflate.deflate(text_field) : text_field
+
+        [keyword, compressed, compression, language_tag, translated_keyword.encode("utf-8"), text_field].pack("Z*CCZ*Z*a*")
+      end
     end
 
     # Maps chunk types to classes, based on the four byte chunk type indicator
@@ -385,15 +434,15 @@ module ChunkyPNG
     #
     # @see ChunkyPNG::Chunk.read
     CHUNK_TYPES = {
-      'IHDR' => Header,
-      'IEND' => End,
-      'IDAT' => ImageData,
-      'PLTE' => Palette,
-      'tRNS' => Transparency,
-      'tEXt' => Text,
-      'zTXt' => CompressedText,
-      'iTXt' => InternationalText,
-      'pHYs' => Physical,
+      "IHDR" => Header,
+      "IEND" => End,
+      "IDAT" => ImageData,
+      "PLTE" => Palette,
+      "tRNS" => Transparency,
+      "tEXt" => Text,
+      "zTXt" => CompressedText,
+      "iTXt" => InternationalText,
+      "pHYs" => Physical,
     }
   end
 end