chunky_png 1.3.1 → 1.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 323e9e7a7ff35bce40522c1f9f26763168fef3e0
+  data.tar.gz: a82e301e630948b3ecdc34bc7edfc3dc89bbdb93
+SHA512:
+  metadata.gz: 2a62b78538767364a849f3c555e1cc3d8204a9dfb58638cf264033bb65d265ff7858c0c873858699906b627a0bcdbf7fbe46ab481a502663a01086470ae70420
+  data.tar.gz: 8be957364e9c0e2aae3b1a4789f370e24db4a5fc62e2458dab4d3e416b93bffd099a43f0bc3934177dfa0d22dfb222ed91a6db279d304655560da41f17a8131f

data/lib/chunky_png/canvas/resampling.rb

@@ -39,8 +39,8 @@ 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(size=new_width, obj=nil)
-        residues = Array.new(size=new_width, obj=nil)
+        indicies = Array.new(new_width, obj=nil)
+        residues = Array.new(new_width, obj=nil)
         
         # This works by accumulating the fractional error and
         # overflowing when necessary.
@@ -80,7 +80,7 @@ module ChunkyPNG
         steps_y = steps(height, new_height)
 
 
-        pixels = Array(size=new_width*new_height)
+        pixels = Array.new(new_width*new_height)
         i = 0
         for y in steps_y
           for x in steps_x
@@ -104,7 +104,7 @@ module ChunkyPNG
         index_x, interp_x = steps_residues(width, new_width)
         index_y, interp_y = steps_residues(height, new_height)
 
-        pixels = Array(size=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

data/lib/chunky_png/chunk.rb

@@ -16,21 +16,33 @@ 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 = io.read(8).unpack('Na4')
-      content      = io.read(length)
-      crc          = io.read(4).unpack('N').first
+      length, type = read_bytes(io, 8).unpack('Na4')
 
+      content = read_bytes(io, length)
+      crc     = read_bytes(io, 4).unpack('N').first
       verify_crc!(type, content, crc)
 
       CHUNK_TYPES.fetch(type, Generic).read(type, content)
     end
 
+    # Reads an exact number of bytes from an IO stream.
+    # @param io [IO, #read] The IO stream to read from.
+    # @param length [Integer] The IO exact number of bytes to read.
+    # @return [String] A binary string of exactly length bytes.
+    # @raise [ChunkyPNG::ExpectationFailed] If not exactly length
+    #   bytes could be read from the IO stream.
+    def self.read_bytes(io, length)
+      data = io.read(length)
+      raise ExpectationFailed, "Couldn't read #{length} bytes from IO stream." if data.nil? || data.bytesize != length
+      data
+    end
+
     # Verifies the CRC of a chunk.
     # @param type [String] The chunk's type.
     # @param content [String] The chunk's content.
     # @param found_crc [Integer] The chunk's found CRC value.
-    # @raise [RuntimeError] An exception is raised if the found CRC value is
-    #   not equal to the expected CRC value.
+    # @raise [ChunkyPNG::CRCMismatch] An exception is raised if
+    #   the found CRC value is not equal to the expected CRC value.
     def self.verify_crc!(type, content, found_crc)
       expected_crc = Zlib.crc32(content, Zlib.crc32(type))
       raise ChunkyPNG::CRCMismatch, "Chuck CRC mismatch!" if found_crc != expected_crc
@@ -232,11 +244,6 @@ module ChunkyPNG
     end
 
     class ImageData < Generic
-      def self.read(type, content)
-        raise ExpectationFailed, 'The IDAT chunk should not be empty!' if content.bytesize == 0
-        super
-      end
-
       def self.combine_chunks(data_chunks)
         Zlib::Inflate.inflate(data_chunks.map { |c| c.content }.join(''))
       end

data/lib/chunky_png/color.rb

@@ -176,6 +176,91 @@ module ChunkyPNG
       base_color | opacity
     end
 
+    # Creates a new color from an HSV triple.
+    #
+    # Create a new color using an HSV (sometimes also called HSB) triple. The
+    # words `value` and `brightness` are used interchangeably and synonymously
+    # in descriptions of this colorspace. This implementation follows the modern
+    # convention of 0 degrees hue indicating red.
+    #
+    # @param [Fixnum] hue The hue component (0-360)
+    # @param [Fixnum] saturation The saturation component (0-1)
+    # @param [Fixnum] value The value (brightness) component (0-1)
+    # @param [Fixnum] alpha Defaults to opaque (255).
+    # @return [Integer] The newly constructed color value.
+    # @raise [ArgumentError] if the hsv triple is invalid.
+    # @see http://en.wikipedia.org/wiki/HSL_and_HSV
+    def from_hsv(hue, saturation, value, alpha = 255)
+      raise ArgumentError, "Hue must be between 0 and 360" unless (0..360).include?(hue)
+      raise ArgumentError, "Saturation must be between 0 and 1" unless (0..1).include?(saturation)
+      raise ArgumentError, "Value/brightness must be between 0 and 1" unless (0..1).include?(value)
+      chroma = value * saturation
+      rgb    = cylindrical_to_cubic(hue, saturation, value, chroma)
+      rgb.map! { |component| ((component + value - chroma) * 255).to_i }
+      rgb << alpha
+      self.rgba(*rgb)
+    end
+    alias_method :from_hsb, :from_hsv
+
+    # Creates a new color from an HSL triple.
+    #
+    # This implementation follows the modern convention of 0 degrees hue
+    # indicating red.
+    #
+    # @param [Fixnum] hue The hue component (0-360)
+    # @param [Fixnum] saturation The saturation component (0-1)
+    # @param [Fixnum] lightness The lightness component (0-1)
+    # @param [Fixnum] alpha Defaults to opaque (255).
+    # @return [Integer] The newly constructed color value.
+    # @raise [ArgumentError] if the hsl triple is invalid.
+    # @see http://en.wikipedia.org/wiki/HSL_and_HSV
+    def from_hsl(hue, saturation, lightness, alpha = 255)
+      raise ArgumentError, "Hue #{hue} was not between 0 and 360" unless (0..360).include?(hue)
+      raise ArgumentError, "Saturation #{saturation} was not between 0 and 1" unless (0..1).include?(saturation)
+      raise ArgumentError, "Lightness #{lightness} was not between 0 and 1" unless (0..1).include?(lightness)
+      chroma = (1 - (2 * lightness - 1).abs) * saturation
+      rgb    = cylindrical_to_cubic(hue, saturation, lightness, chroma)
+      rgb.map! { |component| ((component + lightness - 0.5 * chroma) * 255).to_i }
+      rgb << alpha
+      self.rgba(*rgb)
+    end
+
+    # Convert one HSL or HSV triple and associated chroma to a scaled rgb triple
+    #
+    # This method encapsulates the shared mathematical operations needed to
+    # convert coordinates from a cylindrical colorspace such as HSL or HSV into
+    # coordinates of the RGB colorspace.
+    #
+    # Even though chroma values are derived from the other three coordinates,
+    # the formula for calculating chroma differs for each colorspace.  Since it
+    # is calculated differently for each colorspace, it must be passed in as
+    # a parameter.
+    #
+    # @param [Fixnum] hue The hue-component (0-360)
+    # @param [Fixnum] saturation The saturation-component (0-1)
+    # @param [Fixnum] y_component The y_component can represent either lightness
+    #     or brightness/value (0-1) depending on which scheme (HSV/HSL) is being used.
+    # @param [Fixnum] chroma The associated chroma value.
+    # @return [Array<Fixnum>] A scaled r,g,b triple. Scheme-dependent
+    #    adjustments are still needed to reach the true r,g,b values.
+    # @see http://en.wikipedia.org/wiki/HSL_and_HSV
+    # @see http://www.tomjewett.com/colors/hsb.html
+    # @private
+    def cylindrical_to_cubic(hue, saturation, y_component, chroma)
+      hue_prime = hue.fdiv(60)
+      x = chroma * (1 - (hue_prime % 2 - 1).abs)
+
+      case hue_prime
+      when (0...1); [chroma, x, 0]
+      when (1...2); [x, chroma, 0]
+      when (2...3); [0, chroma, x]
+      when (3...4); [0, x, chroma]
+      when (4...5); [x, 0, chroma]
+      when (5...6); [chroma, 0, x]
+      end
+    end
+    private :cylindrical_to_cubic
+
     ####################################################################
     # PROPERTIES
     ####################################################################
@@ -484,6 +569,91 @@ module ChunkyPNG
       include_alpha ? ('#%08x' % color) : ('#%06x' % [color >> 8])
     end
 
+    # Returns an array with the separate HSV components of a color.
+    #
+    # Because ChunkyPNG internally handles colors as Integers for performance
+    # reasons, some rounding  occurs when importing or exporting HSV colors
+    # whose coordinates are float-based.  Because of this rounding, #to_hsv and
+    # #from_hsv may not be perfect inverses.
+    #
+    # This implementation follows the modern convention of 0 degrees hue
+    # indicating red.
+    #
+    # @param [Integer] color The ChunkyPNG color to convert.
+    # @param [Boolean] include_alpha Flag indicates whether a fourth element
+    #    representing alpha channel should be included in the returned array.
+    # @return [Array<Fixnum>[0]] The hue of the color (0-360)
+    # @return [Array<Fixnum>[1]] The saturation of the color (0-1)
+    # @return [Array<Fixnum>[2]] The value of the color (0-1)
+    # @return [Array<Fixnum>[3]] Optional fourth element for alpha, included if
+    #    include_alpha=true (0-255)
+    # @see http://en.wikipedia.org/wiki/HSL_and_HSV
+    def to_hsv(color, include_alpha = false)
+      hue, chroma, max, min = hue_and_chroma(color)
+      value      = max
+      saturation = chroma.zero? ? 0 : chroma.fdiv(value)
+
+      include_alpha ? [hue, saturation, value, a(color)] :
+                      [hue, saturation, value]
+    end
+    alias_method :to_hsb, :to_hsv
+
+    # Returns an array with the separate HSL components of a color.
+    #
+    # Because ChunkyPNG internally handles colors as Integers for performance
+    # reasons, some rounding  occurs when importing or exporting HSL colors
+    # whose coordinates are float-based.  Because of this rounding, #to_hsl and
+    # #from_hsl may not be perfect inverses.
+    #
+    # This implementation follows the modern convention of 0 degrees hue indicating red.
+    #
+    # @param [Integer] color The ChunkyPNG color to convert.
+    # @param [Boolean] include_alpha Flag indicates whether a fourth element
+    #     representing alpha channel should be included in the returned array.
+    # @return [Array<Fixnum>[0]] The hue of the color (0-360)
+    # @return [Array<Fixnum>[1]] The saturation of the color (0-1)
+    # @return [Array<Fixnum>[2]] The lightness of the color (0-1)
+    # @return [Array<Fixnum>[3]] Optional fourth element for alpha, included if
+    #     include_alpha=true (0-255)
+    # @see http://en.wikipedia.org/wiki/HSL_and_HSV
+    def to_hsl(color, include_alpha = false)
+      hue, chroma, max, min = hue_and_chroma(color)
+      lightness  = 0.5 * (max + min)
+      saturation = chroma.zero? ? 0 : chroma.fdiv(1 - (2*lightness-1).abs)
+
+      include_alpha ? [hue, saturation, lightness, a(color)] :
+                      [hue, saturation, lightness]
+    end
+
+    # This method encapsulates the logic needed to extract hue and chroma from
+    # a ChunkPNG color. This logic is shared by the cylindrical HSV/HSB and HSL
+    # color space models.
+    #
+    # @param [Integer] A ChunkyPNG color.
+    # @return [Fixnum] hue The hue of the color (0-360)
+    # @return [Fixnum] chroma The chroma of the color (0-1)
+    # @return [Fixnum] max The magnitude of the largest scaled rgb component (0-1)
+    # @return [Fixnum] min The magnitude of the smallest scaled rgb component (0-1)
+    # @private
+    def hue_and_chroma(color)
+      scaled_rgb      = to_truecolor_bytes(color)
+      scaled_rgb.map! { |component| component.fdiv(255) }
+      min, max = scaled_rgb.minmax
+      chroma   = max - min
+
+      r, g, b   = scaled_rgb
+      hue_prime = chroma.zero? ? 0 : case max
+                                     when r; (g - b).fdiv(chroma)
+                                     when g; (b - r).fdiv(chroma) + 2
+                                     when b; (r - g).fdiv(chroma) + 4
+                                     else 0
+                                     end
+      hue = 60 * hue_prime
+
+      return hue, chroma, max, min
+    end
+    private :hue_and_chroma
+
     # Returns an array with the separate RGBA values for this color.
     #
     # @param [Integer] color The color to convert.
@@ -540,8 +710,8 @@ module ChunkyPNG
     # Delta E in Lab colorspace, this method should serve many use-cases while
     # avoiding the overhead of converting RGBA to Lab.
     #
-    # @param color_a [Integer]
-    # @param color_b [Integer]
+    # @param pixel_after [Integer]
+    # @param pixel_before [Integer]
     # @return [Float]
     def euclidean_distance_rgba(pixel_after, pixel_before)
       Math.sqrt(

data/lib/chunky_png/dimension.rb

@@ -28,25 +28,37 @@ module ChunkyPNG
   # @raise [ArgumentError] If the argument(s) given where not understood as a dimension.
   # @see ChunkyPNG::Dimension
   def self.Dimension(*args)
-
     case args.length
-      when 2; ChunkyPNG::Dimension.new(*args)
-      when 1; case source = args.first
-          when ChunkyPNG::Dimension; source
-          when ChunkyPNG::Point; ChunkyPNG::Dimension.new(source.x, source.y)
-          when Array; ChunkyPNG::Dimension.new(source[0], source[1])
-          when Hash;  ChunkyPNG::Dimension.new(source[:width] || source['width'], source[:height] || source['height'])
-          when ChunkyPNG::Dimension::DIMENSION_REGEXP; ChunkyPNG::Dimension.new($1, $2)
-          else
-            if source.respond_to?(:width) && source.respond_to?(:height)
-              ChunkyPNG::Dimension.new(source.width, source.height)
-            else
-              raise ArgumentError, "Don't know how to construct a point from #{source.inspect}!"
-            end
-        end
-      else raise ArgumentError, "Don't know how to construct a point from #{args.inspect}!"
+    when 2; ChunkyPNG::Dimension.new(*args)
+    when 1; build_dimension_from_object(args.first)
+    else raise ArgumentError, 
+      "Don't know how to construct a dimension from #{args.inspect}"
+    end
+  end
+
+  def self.build_dimension_from_object(source)
+    case source
+    when ChunkyPNG::Dimension
+      source
+    when ChunkyPNG::Point
+      ChunkyPNG::Dimension.new(source.x, source.y)
+    when Array
+      ChunkyPNG::Dimension.new(source[0], source[1])
+    when Hash
+      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)
+    else
+      if source.respond_to?(:width) && source.respond_to?(:height)
+        ChunkyPNG::Dimension.new(source.width, source.height)
+      else
+        raise ArgumentError, "Don't know how to construct a dimension from #{source.inspect}!"
+      end
     end
   end
+  private_class_method :build_dimension_from_object
   
   # Class that represents the dimension of something, e.g. a {ChunkyPNG::Canvas}.
   #

data/lib/chunky_png/point.rb

@@ -30,24 +30,38 @@ module ChunkyPNG
   # @see ChunkyPNG::Point
   def self.Point(*args)
     case args.length
-      when 2; ChunkyPNG::Point.new(*args)
-      when 1; case source = args.first
-          when ChunkyPNG::Point; source
-          when ChunkyPNG::Dimension; ChunkyPNG::Point.new(source.width, source.height)
-          when Array; ChunkyPNG::Point.new(source[0], source[1])
-          when Hash; ChunkyPNG::Point.new(source[:x] || source['x'], source[:y] || source['y'])
-          when ChunkyPNG::Point::POINT_REGEXP; ChunkyPNG::Point.new($1.to_i, $2.to_i)
-          else 
-            if source.respond_to?(:x) && source.respond_to?(:y)
-              ChunkyPNG::Point.new(source.x, source.y)
-            else
-              raise ArgumentError, "Don't know how to construct a point from #{source.inspect}!"
-            end
-        end
-      else raise ArgumentError, "Don't know how to construct a point from #{args.inspect}!"
+    when 2; ChunkyPNG::Point.new(*args)
+    when 1; build_point_from_object(args.first)
+    else raise ArgumentError, 
+      "Don't know how to construct a point from #{args.inspect}!"
+    end 
+  end
+
+  def self.build_point_from_object(source)
+    case source
+    when ChunkyPNG::Point
+      source
+    when ChunkyPNG::Dimension
+      ChunkyPNG::Point.new(source.width, source.height)
+    when Array
+      ChunkyPNG::Point.new(source[0], source[1])
+    when Hash
+      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 
+      if source.respond_to?(:x) && source.respond_to?(:y)
+        ChunkyPNG::Point.new(source.x, source.y)
+      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.
   #
   # This class implements some basic methods to handle comparison, the splat operator and

data/lib/chunky_png/version.rb

@@ -1,5 +1,5 @@
 module ChunkyPNG
-  # The current version of ChunkyPNG. 
+  # The current version of ChunkyPNG.
   # Set it and commit the change this before running rake release.
-  VERSION = "1.3.1"
+  VERSION = "1.3.2"
 end

data/spec/chunky_png/color_spec.rb

@@ -29,6 +29,9 @@ describe ChunkyPNG::Color do
     @opaque            = 0x0a6496ff
     @non_opaque        = 0x0a649664
     @fully_transparent = 0x0a649600
+    @red               = 0xff0000ff
+    @green             = 0x00ff00ff
+    @blue              = 0x0000ffff
   end
 
   describe '#parse' do
@@ -108,6 +111,69 @@ describe ChunkyPNG::Color do
     end
   end
 
+  describe '#from_hsv' do
+    it 'should load colors correctly from an HSV triple' do
+      # At 0 brightness, should be @black independent of hue or sat
+      from_hsv(0, 0, 0).should        == @black
+      from_hsv(100, 1, 0).should      == @black
+      from_hsv(100, 0.5, 0).should    == @black
+      
+      # At brightness 1 and sat 0, should be @white regardless of hue
+      from_hsv(0, 0, 1).should        == @white
+      from_hsv(100, 0, 1).should      == @white
+
+      # Converting the "pure" colors should work
+      from_hsv(0, 1, 1).should        == @red
+      from_hsv(120, 1, 1).should      == @green
+      from_hsv(240, 1, 1).should      == @blue
+
+      # And, finally, one random color
+      from_hsv(120, 0.5, 0.80).should == 0x66cc66ff
+    end
+
+    it 'should optionally accept a fourth param for alpha' do
+      from_hsv(0, 1, 1, 255).should   == @red
+      from_hsv(120, 1, 1, 255).should == @green
+      from_hsv(240, 1, 1, 255).should == @blue
+      from_hsv(0, 1, 1, 0).should     == 0xff000000 # transparent red
+      from_hsv(120, 1, 1, 0).should   == 0x00ff0000 # transparent green
+      from_hsv(240, 1, 1, 0).should   == 0x0000ff00 # transparent blue
+    end
+  end
+
+  describe '#from_hsl' do
+    it 'should load colors correctly from an HSL triple' do
+      # At 0 lightness, should always be black
+      from_hsl(0, 0, 0).should         == @black
+      from_hsl(100, 0, 0).should       == @black
+      from_hsl(54, 0.5, 0).should      == @black
+      
+      # At 1 lightness, should always be white
+      from_hsl(0, 0, 1).should         == @white
+      from_hsl(0, 0.5, 1).should       == @white
+      from_hsl(110, 0, 1).should       == @white
+      
+      # 'Pure' colors should work
+      from_hsl(0, 1, 0.5).should       == @red
+      from_hsl(120, 1, 0.5).should     == @green
+      from_hsl(240, 1, 0.5).should     == @blue
+      
+      # Random colors
+      from_hsl(87.27, 0.5, 0.5686)     == 0x96c85aff
+      from_hsl(271.83, 0.5399, 0.4176) == 0x6e31a4ff
+      from_hsl(63.6, 0.5984, 0.4882)   == 0xbec732ff
+    end
+
+    it 'should optionally accept a fourth param for alpha' do
+      from_hsl(0, 1, 0.5, 255).should   == @red
+      from_hsl(120, 1, 0.5, 255).should == @green
+      from_hsl(240, 1, 0.5, 255).should == @blue
+      from_hsl(0, 1, 0.5, 0).should     == 0xff000000 # transparent red
+      from_hsl(120, 1, 0.5, 0).should   == 0x00ff0000 # transparent green
+      from_hsl(240, 1, 0.5, 0).should   == 0x0000ff00 # transparent blue
+    end
+  end
+
   describe '#html_color' do
     it 'should find the correct color value' do
       html_color(:springgreen).should   == 0x00ff7fff
@@ -193,6 +259,48 @@ describe ChunkyPNG::Color do
     end
   end
 
+  describe '#to_hsv' do
+    it 'should return a [hue, saturation, value] array' do
+      to_hsv(@white).should     == [0, 0, 1]
+      to_hsv(@black).should     == [0, 0, 0]
+      to_hsv(@red).should       == [0, 1, 1]
+      to_hsv(@blue).should      == [240, 1, 1]
+      to_hsv(@green).should     == [120, 1, 1]
+      to_hsv(0x805440ff)[0].should be_within(1).of(19)
+      to_hsv(0x805440ff)[1].should be_within(0.01).of(0.5)
+      to_hsv(0x805440ff)[2].should be_within(0.01).of(0.5)
+    end
+
+    it 'should optionally include the alpha channel' do
+      to_hsv(@white, true).should                == [0, 0, 1, 255]
+      to_hsv(@red, true).should                  == [0, 1, 1, 255]
+      to_hsv(@blue, true).should                 == [240, 1, 1, 255]
+      to_hsv(@green, true).should                == [120, 1, 1, 255]
+      to_hsv(@opaque, true)[3].should            == 255
+      to_hsv(@fully_transparent, true)[3].should == 0
+    end
+  end
+
+  describe '#to_hsl' do
+    it 'should return a [hue, saturation, lightness] array' do
+      to_hsl(@white).should == [0, 0, 1]
+      to_hsl(@black).should == [0, 0, 0]
+      to_hsl(@red).should   == [0, 1, 0.5]
+      to_hsl(@blue).should  == [240, 1, 0.5]
+      to_hsl(@green).should == [120, 1, 0.5]
+    end
+
+    it 'should optionally include the alpha channel in the returned array' do
+      to_hsl(@white, true).should          == [0, 0, 1, 255]
+      to_hsl(@black, true).should          == [0, 0, 0, 255]
+      to_hsl(@red, true).should            == [0, 1, 0.5, 255]
+      to_hsl(@blue, true).should           == [240, 1, 0.5, 255]
+      to_hsl(@green, true).should          == [120, 1, 0.5, 255]
+      to_hsl(@opaque, true)[3].should      == 255
+      to_hsl(@fully_transparent, true)[3].should == 0
+    end
+  end
+
   describe 'conversion to other formats' do
     it 'should convert the individual color values back correctly' do
       to_truecolor_bytes(@opaque).should == [10, 100, 150]

data/spec/chunky_png/image_spec.rb

@@ -2,24 +2,30 @@ require 'spec_helper'
 
 describe ChunkyPNG::Image do
   describe '#metadata' do
-    
+
     it "should load metadata from an existing file" do
       image = ChunkyPNG::Image.from_file(resource_file('text_chunk.png'))
       image.metadata['Title'].should  == 'My amazing icon!'
       image.metadata['Author'].should == 'Willem van Bergen'
     end
-    
+
     it "should write metadata to the file correctly" do
       filename = resource_file('_metadata.png')
-      
+
       image = ChunkyPNG::Image.new(10, 10)
       image.metadata['Title']  = 'My amazing icon!'
       image.metadata['Author'] = 'Willem van Bergen'
       image.save(filename)
-      
+
       metadata = ChunkyPNG::Datastream.from_file(filename).metadata
       metadata['Title'].should  == 'My amazing icon!'
       metadata['Author'].should == 'Willem van Bergen'
     end
+
+    it "should load empty images correctly" do
+      expect do
+        ChunkyPNG::Image.from_file(resource_file('empty.png'))
+      end.to_not raise_error
+    end
   end
-end
+end

data/spec/chunky_png/point_spec.rb

@@ -43,6 +43,7 @@ end
 
 describe 'ChunkyPNG.Point' do
   subject { ChunkyPNG::Point.new(1, 2) }
+
   
   it "should create a point from a 2-item array" do
     ChunkyPNG::Point([1, 2]).should     == subject
@@ -53,6 +54,11 @@ describe 'ChunkyPNG.Point' do
     ChunkyPNG::Point(:x => 1, :y => 2).should       == subject
     ChunkyPNG::Point('x' => '1', 'y' => '2').should == subject
   end
+
+  it "should create a point from a ChunkyPNG::Dimension object" do
+    dimension = ChunkyPNG::Dimension.new(1, 2)
+    ChunkyPNG::Point(dimension) == subject
+  end
   
   it "should create a point from a point-like string" do
     [

metadata

@@ -1,36 +1,32 @@
 --- !ruby/object:Gem::Specification
 name: chunky_png
 version: !ruby/object:Gem::Version
-  version: 1.3.1
-  prerelease: 
+  version: 1.3.2
 platform: ruby
 authors:
 - Willem van Bergen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-28 00:00:00.000000000 Z
+date: 2014-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -38,12 +34,11 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.2'
-description: ! "    This pure Ruby library can read and write PNG images without depending
+description: "    This pure Ruby library can read and write PNG images without depending
   on an external \n    image library, like RMagick. It tries to be memory efficient
   and reasonably fast.\n    \n    It supports reading and writing all PNG variants
   that are defined in the specification, \n    with one limitation: only 8-bit color
@@ -361,6 +356,7 @@ files:
 - spec/resources/cropped.png
 - spec/resources/damaged_chunk.png
 - spec/resources/damaged_signature.png
+- spec/resources/empty.png
 - spec/resources/lines.png
 - spec/resources/operations.png
 - spec/resources/operations_border.png
@@ -385,6 +381,7 @@ files:
 homepage: http://wiki.github.com/wvanbergen/chunky_png
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options:
 - --title
@@ -396,22 +393,20 @@ rdoc_options:
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Pure ruby library for read/write, chunk-level access to PNG files
 test_files:
 - spec/chunky_png/canvas/adam7_interlacing_spec.rb
@@ -675,6 +670,7 @@ test_files:
 - spec/resources/cropped.png
 - spec/resources/damaged_chunk.png
 - spec/resources/damaged_signature.png
+- spec/resources/empty.png
 - spec/resources/lines.png
 - spec/resources/operations.png
 - spec/resources/operations_border.png