image_size 3.3.0 → 3.5.0

data/lib/image_size.rb

@@ -3,6 +3,7 @@
 
 require 'image_size/isobmff'
 require 'image_size/format_error'
+require 'image_size/media_types'
 require 'image_size/reader'
 require 'image_size/seekable_io_reader'
 require 'image_size/stream_io_reader'
@@ -35,14 +36,30 @@ class ImageSize
     new(Pathname.new(path))
   end
 
-  # Used for svg
+  # Used for svg and emf
   def self.dpi
-    @dpi || 72
+    @dpi || 72.0
   end
 
-  # Used for svg
+  # Used for svg and emf
   def self.dpi=(dpi)
-    @dpi = dpi.to_f
+    fail ArgumentError, "dpi should be nil or positive, got #{dpi}" unless dpi.nil? || dpi > 0
+
+    @dpi = dpi ? dpi.to_f : nil
+  end
+
+  # Size of chunk to use by IO and URI readers
+  def self.chunk_size
+    @chunk_size || 4096
+  end
+
+  # Set size of chunk to use by IO and URI readers
+  def self.chunk_size=(chunk_size)
+    unless chunk_size.nil? || (chunk_size.is_a?(Integer) && chunk_size > 0)
+      fail ArgumentError, "chunk_size should be a positive Integer or nil, got #{chunk_size}"
+    end
+
+    @chunk_size = chunk_size
   end
 
   # Given image as any class responding to read and eof? or data as String, finds its format and dimensions
@@ -50,6 +67,7 @@ class ImageSize
     Reader.open(data) do |ir|
       @format = detect_format(ir)
       @width, @height = send("size_of_#{@format}", ir) if @format
+      @byte_size = ir.byte_size
     end
   end
 
@@ -64,11 +82,26 @@ class ImageSize
   attr_reader :height
   alias_method :h, :height
 
+  attr_reader :byte_size
+
   # get image width and height as an array which to_s method returns "#{width}x#{height}"
   def size
     Size.new([width, height]) if format
   end
 
+  # Media type (formerly known as a MIME type)
+  def media_type
+    media_types.first
+  end
+
+  # All media types:
+  # * commonly used and official like for apng and ico
+  # * main and compatible like for heic and pnm (pbm, pgm, ppm)
+  # * multiple unregistered like for mng
+  def media_types
+    MEDIA_TYPES.fetch(format, [])
+  end
+
 private
 
   SVG_R = /<svg\b([^>]*)>/.freeze
@@ -139,17 +172,13 @@ private
   end
 
   def size_of_mng(ir)
-    unless ir[12, 4] == 'MHDR'
-      raise FormatError, 'MHDR not in place for MNG'
-    end
+    fail FormatError, 'MHDR not in place for MNG' unless ir[12, 4] == 'MHDR'
 
     ir.unpack(16, 8, 'NN')
   end
 
   def size_of_png(ir)
-    unless ir[12, 4] == 'IHDR'
-      raise FormatError, 'IHDR not in place for PNG'
-    end
+    fail FormatError, 'IHDR not in place for PNG' unless ir[12, 4] == 'IHDR'
 
     ir.unpack(16, 8, 'NN')
   end
@@ -167,14 +196,12 @@ private
     loop do
       offset += 1 until [nil, section_marker].include? ir[offset, 1]
       offset += 1 until section_marker != ir[offset + 1, 1]
-      raise FormatError, 'EOF in JPEG' if ir[offset, 1].nil?
+      fail FormatError, 'EOF in JPEG' unless ir[offset, 1]
 
       code, length = ir.unpack(offset, 4, 'xCn')
       offset += 4
 
-      if JPEG_CODE_CHECK.include?(code)
-        return ir.unpack(offset + 1, 4, 'nn').reverse
-      end
+      return ir.unpack(offset + 1, 4, 'nn').reverse if JPEG_CODE_CHECK.include?(code)
 
       offset += length - 2
     end
@@ -198,8 +225,7 @@ private
   def size_of_ppm(ir)
     header = ir[0, 1024]
     header.gsub!(/^\#[^\n\r]*/m, '')
-    header =~ /^(P[1-6])\s+?(\d+)\s+?(\d+)/m
-    [$2.to_i, $3.to_i]
+    header.match(/^(?:P[1-6])\s+?(\d+)\s+?(\d+)/m)[1..2].map(&:to_i)
   end
   alias_method :size_of_pbm, :size_of_ppm
   alias_method :size_of_pgm, :size_of_ppm
@@ -215,37 +241,37 @@ private
         chunk = ir[offset, 32]
         case chunk
         when /\AWIDTH (\d+)\n/
-          width = $1.to_i
+          width = Regexp.last_match[1].to_i
         when /\AHEIGHT (\d+)\n/
-          height = $1.to_i
+          height = Regexp.last_match[1].to_i
         when /\AENDHDR\n/
           break
         when /\A(?:DEPTH|MAXVAL) \d+\n/, /\ATUPLTYPE \S+\n/
           # ignore
         else
-          raise FormatError, "Unexpected data in PAM header: #{chunk.inspect}"
+          fail FormatError, "Unexpected data in PAM header: #{chunk.inspect}"
         end
-        offset += $&.length
+        offset += Regexp.last_match[0].length
       end
     end
     [width, height]
   end
 
   def size_of_xbm(ir)
-    ir[0, 1024] =~ /^\#define\s*\S*\s*(\d+)\s*\n\#define\s*\S*\s*(\d+)/mi
-    [$1.to_i, $2.to_i]
+    ir[0, 1024].match(/^\#define\s*\S*\s*(\d+)\s*\n\#define\s*\S*\s*(\d+)/mi)[1..2].map(&:to_i)
   end
 
   def size_of_xpm(ir)
     length = 1024
-    until (data = ir[0, length]) =~ /"\s*(\d+)\s+(\d+)(\s+\d+\s+\d+){1,2}\s*"/m
-      if data.length != length
-        raise FormatError, 'XPM size not found'
-      end
+    loop do
+      data = ir[0, length]
+      m = data.match(/"\s*(\d+)\s+(\d+)(?:\s+\d+\s+\d+){1,2}\s*"/m)
+      return m[1..2].map(&:to_i) if m
+
+      fail FormatError, 'XPM size not found' if data.length != length
 
       length += 1024
     end
-    [$1.to_i, $2.to_i]
   end
 
   def size_of_psd(ir)
@@ -265,12 +291,12 @@ private
     width = height = nil
     until width && height
       ifd = ir.fetch(offset, 12)
-      raise FormatError, 'Reached end of directory entries in TIFF' if offset > num_dirent
+      fail FormatError, 'Reached end of directory entries in TIFF' if offset > num_dirent
 
       tag, type = ifd.unpack(endian2b * 2)
       offset += 12
 
-      next if packspec[type].nil?
+      next unless packspec[type]
 
       value = ifd[8, 4].unpack(packspec[type])[0]
       case tag
@@ -339,8 +365,8 @@ private
   end
 
   JP2_WALKER = ImageSize::ISOBMFF.new(
-    :recurse => %w[jp2h],
-    :last => %w[jp2h]
+    recurse: %w[jp2h],
+    last: %w[jp2h]
   )
   def size_of_jp2(ir)
     JP2_WALKER.recurse(ir) do |box|
@@ -370,9 +396,9 @@ private
   end
 
   HEIF_WALKER = ImageSize::ISOBMFF.new(
-    :recurse => %w[meta iprp ipco],
-    :full => %w[meta hdlr pitm ipma ispe],
-    :last => %w[meta]
+    recurse: %w[meta iprp ipco],
+    full: %w[meta hdlr pitm ipma ispe],
+    last: %w[meta]
   )
   def size_of_heif(ir)
     pitm = nil
@@ -384,11 +410,11 @@ private
     HEIF_WALKER.recurse(ir) do |box, _path|
       case box.type
       when 'hdlr'
-        raise FormatError, "hdlr box too small (#{box.data_size})" if box.data_size < 8
+        fail FormatError, "hdlr box too small (#{box.data_size})" if box.data_size < 8
 
         return nil unless ir[box.data_offset + 4, 4] == 'pict'
       when 'pitm'
-        raise FormatError, 'second pitm box encountered' if pitm
+        fail FormatError, 'second pitm box encountered' if pitm
 
         pitm = box.version == 0 ? ir.unpack1(box.data_offset, 2, 'n') : ir.unpack1(box.data_offset, 4, 'N')
       when 'ipma'
@@ -430,4 +456,6 @@ private
   end
   alias_method :size_of_avif, :size_of_heif
   alias_method :size_of_heic, :size_of_heif
+
+  private_constant :SVG_R, :XML_R, :JPEG_CODE_CHECK, :JP2_WALKER, :EMF_UMAX, :EMF_SMAX, :HEIF_WALKER
 end

data/spec/image_size/chunky_reader_spec.rb

@@ -29,7 +29,7 @@ describe ImageSize::ChunkyReader do
     {
       'empty string' => '',
       'a bit of data' => 'foo bar baz',
-      'a lot of data' => File.open('GPL', 'rb', &:read),
+      'a lot of data' => File.binread('GPL'),
     }.each do |data_description, data|
       {
         'default' => test_reader.new(data),

data/spec/image_size/isobmff_spec.rb

@@ -53,8 +53,8 @@ describe ImageSize::ISOBMFF do
 
       it do
         is_expected.to yield_successive_args(
-          having_attributes(:type => 'abcd', :data_offset => 8, :data_size => 42),
-          having_attributes(:type => 'efgh', :data_offset => 58, :data_size => 10)
+          having_attributes(type: 'abcd', data_offset: 8, data_size: 42),
+          having_attributes(type: 'efgh', data_offset: 58, data_size: 10)
         )
       end
     end
@@ -74,14 +74,14 @@ describe ImageSize::ISOBMFF do
     describe 'for a box without content' do
       let(:data){ boxes.build{ box('test', 8) } }
 
-      it{ is_expected.to yield_successive_args(having_attributes(:type => 'test', :data_offset => 8, :data_size => 0)) }
+      it{ is_expected.to yield_successive_args(having_attributes(type: 'test', data_offset: 8, data_size: 0)) }
     end
 
     describe 'for a box with content' do
       let(:data){ boxes.build{ box('test', 8 + 42) } }
 
       it do
-        is_expected.to yield_successive_args(having_attributes(:type => 'test', :data_offset => 8, :data_size => 42))
+        is_expected.to yield_successive_args(having_attributes(type: 'test', data_offset: 8, data_size: 42))
       end
     end
 
@@ -100,7 +100,7 @@ describe ImageSize::ISOBMFF do
       let(:data){ boxes.build{ box('test', 0) } }
 
       it do
-        is_expected.to yield_successive_args(having_attributes(:type => 'test', :data_offset => 8, :data_size => nil))
+        is_expected.to yield_successive_args(having_attributes(type: 'test', data_offset: 8, data_size: nil))
       end
     end
 
@@ -116,7 +116,7 @@ describe ImageSize::ISOBMFF do
       let(:data){ boxes.build{ box('test', 1, 16) } }
 
       it do
-        is_expected.to yield_successive_args(having_attributes(:type => 'test', :data_offset => 16, :data_size => 0))
+        is_expected.to yield_successive_args(having_attributes(type: 'test', data_offset: 16, data_size: 0))
       end
     end
 
@@ -124,12 +124,12 @@ describe ImageSize::ISOBMFF do
       let(:data){ boxes.build{ box('test', 1, 16 + 42) } }
 
       it do
-        is_expected.to yield_successive_args(having_attributes(:type => 'test', :data_offset => 16, :data_size => 42))
+        is_expected.to yield_successive_args(having_attributes(type: 'test', data_offset: 16, data_size: 42))
       end
     end
 
     describe 'for a full box' do
-      let(:options){ { :full => %w[test] } }
+      let(:options){ { full: %w[test] } }
 
       let(:data) do
         boxes.build do
@@ -141,18 +141,18 @@ describe ImageSize::ISOBMFF do
       it do
         is_expected.to yield_successive_args(
           having_attributes(
-            :type => 'test',
-            :data_offset => 12,
-            :data_size => 38,
-            :version => 0x61,
-            :flags => 0x626364
+            type: 'test',
+            data_offset: 12,
+            data_size: 38,
+            version: 0x61,
+            flags: 0x626364
           )
         )
       end
     end
 
     describe 'for a big full box' do
-      let(:options){ { :full => %w[test] } }
+      let(:options){ { full: %w[test] } }
 
       let(:data) do
         boxes.build do
@@ -164,11 +164,11 @@ describe ImageSize::ISOBMFF do
       it do
         is_expected.to yield_successive_args(
           having_attributes(
-            :type => 'test',
-            :data_offset => 20,
-            :data_size => 38,
-            :version => 0x61,
-            :flags => 0x626364
+            type: 'test',
+            data_offset: 20,
+            data_size: 38,
+            version: 0x61,
+            flags: 0x626364
           )
         )
       end
@@ -206,8 +206,8 @@ describe ImageSize::ISOBMFF do
 
         it do
           is_expected.to yield_successive_args(
-            having_attributes(:type => 'fooo', :data_offset => 16, :data_size => 0),
-            having_attributes(:type => 'barr', :data_offset => 24, :data_size => 0)
+            having_attributes(type: 'fooo', data_offset: 16, data_size: 0),
+            having_attributes(type: 'barr', data_offset: 24, data_size: 0)
           )
         end
       end
@@ -230,7 +230,7 @@ describe ImageSize::ISOBMFF do
         let(:length){ 8 }
 
         it do
-          is_expected.to yield_successive_args(having_attributes(:type => 'fooo', :data_offset => 16, :data_size => 0))
+          is_expected.to yield_successive_args(having_attributes(type: 'fooo', data_offset: 16, data_size: 0))
         end
       end
     end
@@ -256,24 +256,24 @@ describe ImageSize::ISOBMFF do
     end
 
     context 'when configured to recures all' do
-      let(:options){ { :recurse => %w[fooA barA barB bazA] } }
+      let(:options){ { recurse: %w[fooA barA barB bazA] } }
 
       it 'recurses complete tree' do
         enum = instance.to_enum(:recurse, string_reader)
 
-        expect(enum.next).to have_attributes(:type => 'fooA', :data_offset => 8, :data_size => 10)
+        expect(enum.next).to have_attributes(type: 'fooA', data_offset: 8, data_size: 10)
 
-        expect(enum.next).to have_attributes(:type => 'fooB', :data_offset => 16, :data_size => 2)
+        expect(enum.next).to have_attributes(type: 'fooB', data_offset: 16, data_size: 2)
 
-        expect(enum.next).to have_attributes(:type => 'barA', :data_offset => 26, :data_size => 18)
+        expect(enum.next).to have_attributes(type: 'barA', data_offset: 26, data_size: 18)
 
-        expect(enum.next).to have_attributes(:type => 'barB', :data_offset => 34, :data_size => 10)
+        expect(enum.next).to have_attributes(type: 'barB', data_offset: 34, data_size: 10)
 
-        expect(enum.next).to have_attributes(:type => 'barC', :data_offset => 42, :data_size => 2)
+        expect(enum.next).to have_attributes(type: 'barC', data_offset: 42, data_size: 2)
 
-        expect(enum.next).to have_attributes(:type => 'bazA', :data_offset => 52, :data_size => 10)
+        expect(enum.next).to have_attributes(type: 'bazA', data_offset: 52, data_size: 10)
 
-        expect(enum.next).to have_attributes(:type => 'bazB', :data_offset => 60, :data_size => 2)
+        expect(enum.next).to have_attributes(type: 'bazB', data_offset: 60, data_size: 2)
 
         expect{ enum.next }.to raise_exception(StopIteration)
       end
@@ -284,18 +284,18 @@ describe ImageSize::ISOBMFF do
     end
 
     context 'when configured to recurse part' do
-      let(:options){ { :recurse => %w[barA] } }
+      let(:options){ { recurse: %w[barA] } }
 
       it 'recurses requested part' do
         enum = instance.to_enum(:recurse, string_reader)
 
-        expect(enum.next).to have_attributes(:type => 'fooA', :data_offset => 8, :data_size => 10)
+        expect(enum.next).to have_attributes(type: 'fooA', data_offset: 8, data_size: 10)
 
-        expect(enum.next).to have_attributes(:type => 'barA', :data_offset => 26, :data_size => 18)
+        expect(enum.next).to have_attributes(type: 'barA', data_offset: 26, data_size: 18)
 
-        expect(enum.next).to have_attributes(:type => 'barB', :data_offset => 34, :data_size => 10)
+        expect(enum.next).to have_attributes(type: 'barB', data_offset: 34, data_size: 10)
 
-        expect(enum.next).to have_attributes(:type => 'bazA', :data_offset => 52, :data_size => 10)
+        expect(enum.next).to have_attributes(type: 'bazA', data_offset: 52, data_size: 10)
 
         expect{ enum.next }.to raise_exception(StopIteration)
       end
@@ -311,11 +311,11 @@ describe ImageSize::ISOBMFF do
       it 'does not recurse' do
         enum = instance.to_enum(:recurse, string_reader)
 
-        expect(enum.next).to have_attributes(:type => 'fooA', :data_offset => 8, :data_size => 10)
+        expect(enum.next).to have_attributes(type: 'fooA', data_offset: 8, data_size: 10)
 
-        expect(enum.next).to have_attributes(:type => 'barA', :data_offset => 26, :data_size => 18)
+        expect(enum.next).to have_attributes(type: 'barA', data_offset: 26, data_size: 18)
 
-        expect(enum.next).to have_attributes(:type => 'bazA', :data_offset => 52, :data_size => 10)
+        expect(enum.next).to have_attributes(type: 'bazA', data_offset: 52, data_size: 10)
 
         expect{ enum.next }.to raise_exception(StopIteration)
       end
@@ -326,20 +326,20 @@ describe ImageSize::ISOBMFF do
     end
 
     context 'when configured to stop' do
-      let(:options){ { :recurse => %w[fooA barA barB bazA], :last => %w[barA] } }
+      let(:options){ { recurse: %w[fooA barA barB bazA], last: %w[barA] } }
 
       it 'recurses complete tree' do
         enum = instance.to_enum(:recurse, string_reader)
 
-        expect(enum.next).to have_attributes(:type => 'fooA', :data_offset => 8, :data_size => 10)
+        expect(enum.next).to have_attributes(type: 'fooA', data_offset: 8, data_size: 10)
 
-        expect(enum.next).to have_attributes(:type => 'fooB', :data_offset => 16, :data_size => 2)
+        expect(enum.next).to have_attributes(type: 'fooB', data_offset: 16, data_size: 2)
 
-        expect(enum.next).to have_attributes(:type => 'barA', :data_offset => 26, :data_size => 18)
+        expect(enum.next).to have_attributes(type: 'barA', data_offset: 26, data_size: 18)
 
-        expect(enum.next).to have_attributes(:type => 'barB', :data_offset => 34, :data_size => 10)
+        expect(enum.next).to have_attributes(type: 'barB', data_offset: 34, data_size: 10)
 
-        expect(enum.next).to have_attributes(:type => 'barC', :data_offset => 42, :data_size => 2)
+        expect(enum.next).to have_attributes(type: 'barC', data_offset: 42, data_size: 2)
 
         expect{ enum.next }.to raise_exception(StopIteration)
       end

data/spec/image_size/seekable_io_reader_spec.rb

@@ -6,45 +6,40 @@ require 'image_size/seekable_io_reader'
 
 describe ImageSize::SeekableIOReader do
   context :[] do
-    def ios
-      @ios ||= []
-    end
-
-    def io
-      File.open('GPL', 'rb').tap do |io|
-        ios << io
-      end
-    end
-
-    after do
-      ios.pop.close until ios.empty?
+    def new_io(&block)
+      File.open('GPL', 'rb', &block)
     end
 
     def new_reader
-      ImageSize::SeekableIOReader.new(io)
+      new_io do |io|
+        yield ImageSize::SeekableIOReader.new(io)
+      end
     end
 
-    let(:content){ io.read }
+    let(:content){ new_io(&:read) }
 
     it 'reads as expected when pieces are read consecutively' do
-      reader = new_reader
-      0.step(content.length + 4096, 100) do |offset|
-        expect(reader[offset, 100]).to eq(content[offset, 100])
+      new_reader do |reader|
+        0.step(content.length + 4096, 100) do |offset|
+          expect(reader[offset, 100]).to eq(content[offset, 100])
+        end
       end
     end
 
     it 'reads as expected when pieces are read backwards' do
-      reader = new_reader
-      (content.length + 4096).step(0, -100) do |offset|
-        expect(reader[offset, 100]).to eq(content[offset, 100])
+      new_reader do |reader|
+        (content.length + 4096).step(0, -100) do |offset|
+          expect(reader[offset, 100]).to eq(content[offset, 100])
+        end
       end
     end
 
     it 'reads as expected when pieces are read in random order' do
       100.times do
-        reader = new_reader
-        0.step(content.length + 4096, 100).to_a.shuffle.each do |offset|
-          expect(reader[offset, 100]).to eq(content[offset, 100])
+        new_reader do |reader|
+          0.step(content.length + 4096, 100).to_a.shuffle.each do |offset|
+            expect(reader[offset, 100]).to eq(content[offset, 100])
+          end
         end
       end
     end