chunky_png 1.3.9 → 1.3.14

data/lib/chunky_png/datastream.rb

@@ -1,5 +1,6 @@
-module ChunkyPNG
+# frozen-string-literal: true
 
+module ChunkyPNG
   # The Datastream class represents a PNG formatted datastream. It supports
   # both reading from and writing to strings, streams and files.
   #
@@ -9,9 +10,8 @@ module ChunkyPNG
   #
   # @see ChunkyPNG::Chunk
   class Datastream
-
     # The signature that each PNG file or stream should begin with.
-    SIGNATURE = ChunkyPNG.force_binary([137, 80, 78, 71, 13, 10, 26, 10].pack('C8'))
+    SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10].pack("C8").force_encoding(::Encoding::BINARY).freeze
 
     # The header chunk of this datastream.
     # @return [ChunkyPNG::Chunk::Header]
@@ -52,22 +52,21 @@ module ChunkyPNG
     ##############################################################################
 
     class << self
-
       # Reads a PNG datastream from a string.
       # @param [String] str The PNG encoded string to load from.
       # @return [ChunkyPNG::Datastream] The loaded datastream instance.
       def from_blob(str)
-        from_io(StringIO.new(str))
+        from_io(StringIO.new(str, "rb"))
       end
 
-      alias :from_string :from_blob
+      alias from_string from_blob
 
       # Reads a PNG datastream from a file.
       # @param [String] filename The path of the file to load from.
       # @return [ChunkyPNG::Datastream] The loaded datastream instance.
       def from_file(filename)
         ds = nil
-        File.open(filename, 'rb') { |f| ds = from_io(f) }
+        File.open(filename, "rb") { |f| ds = from_io(f) }
         ds
       end
 
@@ -75,22 +74,23 @@ module ChunkyPNG
       # @param [IO] io The stream to read from.
       # @return [ChunkyPNG::Datastream] The loaded datastream instance.
       def from_io(io)
+        io.set_encoding(::Encoding::BINARY)
         verify_signature!(io)
 
-        ds = self.new
+        ds = new
         while ds.end_chunk.nil?
           chunk = ChunkyPNG::Chunk.read(io)
           case chunk
-            when ChunkyPNG::Chunk::Header;       ds.header_chunk = chunk
-            when ChunkyPNG::Chunk::Palette;      ds.palette_chunk = chunk
-            when ChunkyPNG::Chunk::Transparency; ds.transparency_chunk = chunk
-            when ChunkyPNG::Chunk::ImageData;    ds.data_chunks << chunk
-            when ChunkyPNG::Chunk::Physical;     ds.physical_chunk = chunk
-            when ChunkyPNG::Chunk::End;          ds.end_chunk = chunk
+            when ChunkyPNG::Chunk::Header       then ds.header_chunk = chunk
+            when ChunkyPNG::Chunk::Palette      then ds.palette_chunk = chunk
+            when ChunkyPNG::Chunk::Transparency then ds.transparency_chunk = chunk
+            when ChunkyPNG::Chunk::ImageData    then ds.data_chunks << chunk
+            when ChunkyPNG::Chunk::Physical     then ds.physical_chunk = chunk
+            when ChunkyPNG::Chunk::End          then ds.end_chunk = chunk
             else ds.other_chunks << chunk
           end
         end
-        return ds
+        ds
       end
 
       # Verifies that the current stream is a PNG datastream by checking its signature.
@@ -103,7 +103,7 @@ module ChunkyPNG
       #    the beginning of the stream.
       def verify_signature!(io)
         signature = io.read(ChunkyPNG::Datastream::SIGNATURE.length)
-        unless ChunkyPNG.force_binary(signature) == ChunkyPNG::Datastream::SIGNATURE
+        unless signature == ChunkyPNG::Datastream::SIGNATURE
           raise ChunkyPNG::SignatureMismatch, "PNG signature not found, found #{signature.inspect} instead of #{ChunkyPNG::Datastream::SIGNATURE.inspect}!"
         end
       end
@@ -127,7 +127,7 @@ module ChunkyPNG
       yield(palette_chunk)      if palette_chunk
       yield(transparency_chunk) if transparency_chunk
       yield(physical_chunk)     if physical_chunk
-      data_chunks.each  { |chunk| yield(chunk) }
+      data_chunks.each { |chunk| yield(chunk) }
       yield(end_chunk)
     end
 
@@ -142,8 +142,8 @@ module ChunkyPNG
     # @return [Hash] A hash containing metadata fields and their values.
     def metadata
       metadata = {}
-      other_chunks.select do |chunk|
-        metadata[chunk.keyword] = chunk.value if chunk.respond_to?(:keyword)
+      other_chunks.each do |chunk|
+        metadata[chunk.keyword] = chunk.value if chunk.respond_to?(:keyword) && chunk.respond_to?(:value)
       end
       metadata
     end
@@ -158,12 +158,6 @@ module ChunkyPNG
     # WRITING DATASTREAMS
     ##################################################################################
 
-    # Returns an empty stream using binary encoding that can be used as stream to encode to.
-    # @return [String] An empty, binary string.
-    def self.empty_bytearray
-      ChunkyPNG::EMPTY_BYTEARRAY.dup
-    end
-
     # Writes the datastream to the given output stream.
     # @param [IO] io The output stream to write to.
     def write(io)
@@ -174,19 +168,19 @@ module ChunkyPNG
     # Saves this datastream as a PNG file.
     # @param [String] filename The filename to use.
     def save(filename)
-      File.open(filename, 'wb') { |f| write(f) }
+      File.open(filename, "wb") { |f| write(f) }
     end
 
     # Encodes this datastream into a string.
     # @return [String] The encoded PNG datastream.
     def to_blob
       str = StringIO.new
-      str.set_encoding('ASCII-8BIT')
+      str.set_encoding("ASCII-8BIT")
       write(str)
-      return str.string
+      str.string
     end
 
-    alias :to_string :to_blob
-    alias :to_s :to_blob
+    alias to_string to_blob
+    alias to_s to_blob
   end
 end

data/lib/chunky_png/dimension.rb

@@ -1,5 +1,6 @@
-module ChunkyPNG
+# frozen-string-literal: true
 
+module ChunkyPNG
   # Creates a {ChunkyPNG::Dimension} instance using arguments that can be interpreted
   # as width and height.
   #
@@ -29,8 +30,8 @@ module ChunkyPNG
   # @see ChunkyPNG::Dimension
   def self.Dimension(*args)
     case args.length
-    when 2; ChunkyPNG::Dimension.new(*args)
-    when 1; build_dimension_from_object(args.first)
+    when 2 then ChunkyPNG::Dimension.new(*args)
+    when 1 then build_dimension_from_object(args.first)
     else raise ArgumentError,
       "Don't know how to construct a dimension from #{args.inspect}"
     end
@@ -45,8 +46,8 @@ module ChunkyPNG
     when Array
       ChunkyPNG::Dimension.new(source[0], source[1])
     when Hash
-      width = source[:width] || source['width']
-      height = source[:height] || source['height']
+      width = source[:width] || source["width"]
+      height = source[:height] || source["height"]
       ChunkyPNG::Dimension.new(width, height)
     when ChunkyPNG::Dimension::DIMENSION_REGEXP
       ChunkyPNG::Dimension.new($1, $2)
@@ -58,13 +59,13 @@ module ChunkyPNG
       end
     end
   end
+
   private_class_method :build_dimension_from_object
 
   # Class that represents the dimension of something, e.g. a {ChunkyPNG::Canvas}.
   #
   # This class contains some methods to simplify performing dimension related checks.
   class Dimension
-
     # @return [Regexp] The regexp to parse dimensions from a string.
     # @private
     DIMENSION_REGEXP = /^[\(\[\{]?(\d+)\s*[x,]?\s*(\d+)[\)\]\}]?$/
@@ -89,7 +90,7 @@ module ChunkyPNG
     end
 
     # Checks whether a point is within bounds of this dimension.
-    # @param [ChunkyPNG::Point, ...] A point-like to bounds-check.
+    # @param [ChunkyPNG::Point, ...] point_like A point-like to bounds-check.
     # @return [true, false] True iff the x and y coordinate fall in this dimension.
     # @see ChunkyPNG.Point
     def include?(*point_like)
@@ -98,17 +99,23 @@ module ChunkyPNG
     end
 
     # Checks whether 2 dimensions are identical.
-    # @param [ChunkyPNG::Dimension] The dimension to compare with.
+    # @param [ChunkyPNG::Dimension] other The dimension to compare with.
     # @return [true, false] <tt>true</tt> iff width and height match.
     def eql?(other)
       return false unless other.respond_to?(:width) && other.respond_to?(:height)
       other.width == width && other.height == height
     end
 
-    alias_method :==, :eql?
+    alias == eql?
+
+    # Calculates a hash for the dimension object, based on width and height
+    # @return [Integer] A hashed value of the dimensions
+    def hash
+      [width, height].hash
+    end
 
     # Compares the size of 2 dimensions.
-    # @param [ChunkyPNG::Dimension] The dimension to compare with.
+    # @param [ChunkyPNG::Dimension] other The dimension to compare with.
     # @return [-1, 0, 1] -1 if the other dimension has a larger area, 1 of this
     #   dimension is larger, 0 if both are identical in size.
     def <=>(other)
@@ -121,6 +128,6 @@ module ChunkyPNG
       [width, height]
     end
 
-    alias_method :to_ary, :to_a
+    alias to_ary to_a
   end
 end

data/lib/chunky_png/image.rb

@@ -1,18 +1,18 @@
-module ChunkyPNG
+# frozen-string-literal: true
 
+module ChunkyPNG
   # ChunkyPNG::Image is an extension of the {ChunkyPNG::Canvas} class, that
   # also includes support for metadata.
   #
   # @see ChunkyPNG::Canvas
   class Image < Canvas
-
     # The minimum size of bytes the value of a metadata field should be before compression
     # is enabled for the chunk.
     METADATA_COMPRESSION_TRESHOLD = 300
-    
+
     # @return [Hash] The hash of metadata fields for this PNG image.
     attr_accessor :metadata
-    
+
     # Initializes a new ChunkyPNG::Image instance.
     # @param [Integer] width The width of the new image.
     # @param [Integer] height The height of the new image.
@@ -23,7 +23,7 @@ module ChunkyPNG
       super(width, height, bg_color)
       @metadata = metadata
     end
-    
+
     # Initializes a copy of another ChunkyPNG::Image instance.
     #
     # @param [ChunkyPNG::Image] other The other image to copy.
@@ -31,7 +31,7 @@ module ChunkyPNG
       super(other)
       @metadata = other.metadata
     end
-    
+
     # Returns the metadata for this image as PNG chunks.
     #
     # Chunks will either be of the {ChunkyPNG::Chunk::Text} type for small
@@ -49,7 +49,7 @@ module ChunkyPNG
         end
       end
     end
-    
+
     # Encodes the image to a PNG datastream for saving to disk or writing to an IO stream.
     #
     # Besides encoding the canvas, it will also encode the metadata fields to text chunks.
@@ -61,19 +61,19 @@ module ChunkyPNG
     def to_datastream(constraints = {})
       ds = super(constraints)
       ds.other_chunks += metadata_chunks
-      return ds
+      ds
     end
-    
+
     # Reads a ChunkyPNG::Image instance from a data stream.
     #
     # Besides decoding the canvas, this will also read the metadata fields
     # from the datastream.
     #
-    # @param [ChunkyPNG::Datastream] The datastream to read from.
+    # @param [ChunkyPNG::Datastream] ds The datastream to read from.
     def self.from_datastream(ds)
       image = super(ds)
       image.metadata = ds.metadata
-      return image
+      image
     end
   end
 end

data/lib/chunky_png/palette.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module ChunkyPNG
   # A palette describes the set of colors that is being used for an image.
   #
@@ -40,12 +42,8 @@ module ChunkyPNG
       decoding_map = []
       index = 0
 
-      palatte_bytes = palette_chunk.content.unpack('C*')
-      if transparency_chunk
-        alpha_channel = transparency_chunk.content.unpack('C*')
-      else
-        alpha_channel = []
-      end
+      palatte_bytes = palette_chunk.content.unpack("C*")
+      alpha_channel = transparency_chunk ? transparency_chunk.content.unpack("C*") : []
 
       index = 0
       palatte_bytes.each_slice(3) do |bytes|
@@ -165,7 +163,7 @@ module ChunkyPNG
     #
     # @return [ChunkyPNG::Chunk::Transparency] The tRNS chunk.
     def to_trns_chunk
-      ChunkyPNG::Chunk::Transparency.new('tRNS', map { |c| ChunkyPNG::Color.a(c) }.pack('C*'))
+      ChunkyPNG::Chunk::Transparency.new("tRNS", map { |c| ChunkyPNG::Color.a(c) }.pack("C*"))
     end
 
     # Creates a PLTE chunk that corresponds with this palette to store the r,
@@ -186,7 +184,7 @@ module ChunkyPNG
         colors += ChunkyPNG::Color.to_truecolor_bytes(color)
       end
 
-      ChunkyPNG::Chunk::Palette.new('PLTE', colors.pack('C*'))
+      ChunkyPNG::Chunk::Palette.new("PLTE", colors.pack("C*"))
     end
 
     # Determines the most suitable colormode for this palette.
@@ -219,7 +217,6 @@ module ChunkyPNG
       when 3..4 then 2
       when 5..16 then 4
       when 17..256 then 8
-      else nil
       end
     end
   end

data/lib/chunky_png/point.rb

@@ -1,11 +1,12 @@
+# frozen-string-literal: true
+
 module ChunkyPNG
-  
   # Factory method to create {ChunkyPNG::Point} instances.
-  # 
-  # This method tries to be as flexible as possible with regards to the given input: besides 
+  #
+  # This method tries to be as flexible as possible with regards to the given input: besides
   # explicit coordinates, this method also accepts arrays, hashes, strings, {ChunkyPNG::Dimension}
   # instances and anything that responds to <tt>:x</tt> and <tt>:y</tt>.
-  # 
+  #
   # @overload Point(x, y)
   #   @param [Integer, :to_i] x The x-coordinate
   #   @param [Integer, :to_i] y The y-coordinate
@@ -30,11 +31,11 @@ module ChunkyPNG
   # @see ChunkyPNG::Point
   def self.Point(*args)
     case args.length
-    when 2; ChunkyPNG::Point.new(*args)
-    when 1; build_point_from_object(args.first)
-    else raise ArgumentError, 
+    when 2 then ChunkyPNG::Point.new(*args)
+    when 1 then build_point_from_object(args.first)
+    else raise ArgumentError,
       "Don't know how to construct a point from #{args.inspect}!"
-    end 
+    end
   end
 
   def self.build_point_from_object(source)
@@ -46,20 +47,21 @@ module ChunkyPNG
     when Array
       ChunkyPNG::Point.new(source[0], source[1])
     when Hash
-      x = source[:x] || source['x']
-      y = source[:y] || source['y']
+      x = source[:x] || source["x"]
+      y = source[:y] || source["y"]
       ChunkyPNG::Point.new(x, y)
     when ChunkyPNG::Point::POINT_REGEXP
       ChunkyPNG::Point.new($1.to_i, $2.to_i)
-    else 
+    else
       if source.respond_to?(:x) && source.respond_to?(:y)
         ChunkyPNG::Point.new(source.x, source.y)
-      else 
-        raise ArgumentError, 
+      else
+        raise ArgumentError,
           "Don't know how to construct a point from #{source.inspect}!"
       end
     end
   end
+
   private_class_method :build_point_from_object
 
   # Simple class that represents a point on a canvas using an x and y coordinate.
@@ -69,7 +71,6 @@ module ChunkyPNG
   #
   # @see ChunkyPNG.Point
   class Point
-    
     # @return [Regexp] The regexp to parse points from a string.
     # @private
     POINT_REGEXP = /^[\(\[\{]?(\d+)\s*[,]?\s*(\d+)[\)\]\}]?$/
@@ -79,22 +80,22 @@ module ChunkyPNG
 
     # @return [Integer] The y-coordinate of the point.
     attr_accessor :y
-    
+
     # Initializes a new point instance.
     # @param [Integer, :to_i] x The x-coordinate.
     # @param [Integer, :to_i] y The y-coordinate.
     def initialize(x, y)
       @x, @y = x.to_i, y.to_i
     end
-    
+
     # Checks whether 2 points are identical.
     # @return [true, false] <tt>true</tt> iff the x and y coordinates match
     def eql?(other)
       other.x == x && other.y == y
     end
-    
-    alias_method :==, :eql?
-    
+
+    alias == eql?
+
     # Compares 2 points.
     #
     # It will first compare the y coordinate, and it only takes the x-coordinate into
@@ -106,21 +107,21 @@ module ChunkyPNG
     # @return [-1, 0, 1] <tt>-1</tt> If this point comes before the other one, <tt>1</tt>
     #   if after, and <tt>0</tt> if the points are identical.
     def <=>(other)
-      ((y <=> other.y) == 0) ? x <=> other.x : y <=> other.y
+      (y <=> other.y) == 0 ? x <=> other.x : y <=> other.y
     end
-    
+
     # Converts the point instance to an array.
     # @return [Array] A 2-element array, i.e. <tt>[x, y]</tt>.
     def to_a
       [x, y]
     end
-    
-    alias_method :to_ary, :to_a
-    
+
+    alias to_ary to_a
+
     # Checks whether the point falls into a dimension
-    # @param [ChunkyPNG::Dimension, ...] dimension_like The dimension of which the bounds 
+    # @param [ChunkyPNG::Dimension, ...] dimension_like The dimension of which the bounds
     #   should be taken for the check.
-    # @return [true, false] <tt>true</tt> iff the x and y coordinate fall width the width 
+    # @return [true, false] <tt>true</tt> iff the x and y coordinate fall width the width
     #   and height of the dimension.
     def within_bounds?(*dimension_like)
       ChunkyPNG::Dimension(*dimension_like).include?(self)