image_size 3.4.0 → 3.6.0

data/lib/image_size.rb

@@ -31,19 +31,40 @@ class ImageSize
     alias_method :h, :height
   end
 
-  # Given path to image finds its format, width and height
-  def self.path(path)
-    new(Pathname.new(path))
-  end
+  class << self
+    # Given path to image finds its format, width and height
+    def path(path)
+      new(Pathname.new(path))
+    end
 
-  # Used for svg
-  def self.dpi
-    @dpi || 72
-  end
+    # DPI used for svg and emf
+    def dpi
+      @dpi || 72.0
+    end
+
+    # Set DPI used for svg and emf
+    def dpi=(dpi)
+      fail ArgumentError, "dpi should be nil or positive, got #{dpi}" unless dpi.nil? || dpi > 0
 
-  # Used for svg
-  def self.dpi=(dpi)
-    @dpi = dpi.to_f
+      @dpi = dpi ? dpi.to_f : nil
+    end
+
+    # Use display pixels instead of physical/image pixels for icns
+    attr_accessor :use_display_pixels
+
+    # Size of chunk to use by IO and URI readers
+    def chunk_size
+      @chunk_size || 4096
+    end
+
+    # Set size of chunk to use by IO and URI readers
+    def 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
   end
 
   # Given image as any class responding to read and eof? or data as String, finds its format and dimensions
@@ -51,6 +72,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
 
@@ -65,6 +87,8 @@ 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
@@ -72,7 +96,7 @@ class ImageSize
 
   # Media type (formerly known as a MIME type)
   def media_type
-    MEDIA_TYPES.fetch(format, []).first
+    media_types.first
   end
 
   # All media types:
@@ -87,6 +111,8 @@ private
 
   SVG_R = /<svg\b([^>]*)>/.freeze
   XML_R = /<\?xml|<!--/.freeze
+  private_constant :SVG_R, :XML_R
+
   def detect_format(ir)
     head = ir[0, 1024]
     case
@@ -107,6 +133,7 @@ private
     when head[0, 12] =~ /\ARIFF(?m:....)WEBP\z/                   then :webp
     when head[0, 4] == "\0\0\1\0"                                 then :ico
     when head[0, 4] == "\0\0\2\0"                                 then :cur
+    when head[0, 4] == 'icns'                                     then :icns
     when head[0, 12] == "\0\0\0\fjP  \r\n\207\n"                  then detect_jpeg2000_type(ir)
     when head[0, 4] == "\377O\377Q"                               then :j2c
     when head[0, 4] == "\1\0\0\0" && head[40, 4] == ' EMF'        then :emf
@@ -153,13 +180,13 @@ private
   end
 
   def size_of_mng(ir)
-    raise FormatError, 'MHDR not in place for MNG' unless ir[12, 4] == 'MHDR'
+    fail FormatError, 'MHDR not in place for MNG' unless ir[12, 4] == 'MHDR'
 
     ir.unpack(16, 8, 'NN')
   end
 
   def size_of_png(ir)
-    raise FormatError, 'IHDR not in place for PNG' unless ir[12, 4] == 'IHDR'
+    fail FormatError, 'IHDR not in place for PNG' unless ir[12, 4] == 'IHDR'
 
     ir.unpack(16, 8, 'NN')
   end
@@ -171,13 +198,15 @@ private
     0xC9, 0xCA, 0xCB,
     0xCD, 0xCE, 0xCF
   ].freeze
+  private_constant :JPEG_CODE_CHECK
+
   def size_of_jpeg(ir)
     section_marker = "\xFF"
     offset = 2
     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' unless ir[offset, 1]
+      fail FormatError, 'EOF in JPEG' unless ir[offset, 1]
 
       code, length = ir.unpack(offset, 4, 'xCn')
       offset += 4
@@ -206,8 +235,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
@@ -223,35 +251,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
-      raise FormatError, 'XPM size not found' if data.length != length
+    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)
@@ -271,7 +301,7 @@ 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
@@ -331,6 +361,60 @@ private
   end
   alias_method :size_of_cur, :size_of_ico
 
+  ICNS_16X12 = %w[icm# icm4 icm8].freeze
+  ICNS_SQUARE = {
+    [16, 1] => %w[ic04 icp4 ics# ics4 ics8 is32 s8mk],
+    [16, 2] => %w[ic11],
+    [18, 1] => %w[icsb],
+    [18, 2] => %w[icsB],
+    [24, 1] => %w[sb24],
+    [24, 2] => %w[SB24],
+    [32, 1] => %w[ICN# ICON ic05 icl4 icl8 icp5 il32 l8mk],
+    [32, 2] => %w[ic12],
+    [48, 1] => %w[h8mk ich# ich4 ich8 icp6 ih32],
+    [128, 1] => %w[ic07 it32 t8mk],
+    [128, 2] => %w[ic13],
+    [256, 1] => %w[ic08],
+    [256, 2] => %w[ic14],
+    [512, 1] => %w[ic09],
+    [512, 2] => %w[ic10],
+  }.each_with_object({}){ |(spec, types), h| types.each{ |type| h[type] = spec } }.freeze
+  private_constant :ICNS_16X12, :ICNS_SQUARE
+
+  def size_of_icns(ir)
+    file_length = ir.unpack1(4, 4, 'N')
+    offset = 8
+
+    types = []
+    while offset < file_length
+      type = ir[offset, 4]
+      length = ir.unpack1(offset + 4, 4, 'N')
+
+      case type
+      when 'TOC ' # rely on table of contents
+        fail FormatError, "TOC length #{length} is not divisible by 8" unless length % 8 == 0
+
+        types = (1...(length / 8)).map{ |i| ir[offset + (8 * i), 4] }
+        break
+      when 'icnV', 'info', 'name' # not icons
+      when 'slct', 'sbtp', "\375\331/\250" # nested icns
+      else
+        types << type
+      end
+
+      offset += length
+    end
+
+    types.map do |type|
+      next [16, 12] if ICNS_16X12.include?(type)
+
+      side, scale = ICNS_SQUARE[type]
+      fail FormatError, "unknown icon type: #{type.inspect}" unless side
+
+      (self.class.use_display_pixels ? [side] : [side * scale]) * 2
+    end.max
+  end
+
   def size_of_webp(ir)
     case ir.fetch(12, 4)
     when 'VP8 '
@@ -348,6 +432,8 @@ private
     recurse: %w[jp2h],
     last: %w[jp2h]
   )
+  private_constant :JP2_WALKER
+
   def size_of_jp2(ir)
     JP2_WALKER.recurse(ir) do |box|
       return ir.unpack(box.data_offset, 8, 'NN').reverse if box.type == 'ihdr'
@@ -361,6 +447,7 @@ private
 
   EMF_UMAX = 256**4
   EMF_SMAX = EMF_UMAX / 2
+  private_constant :EMF_UMAX, :EMF_SMAX
 
   def size_of_emf(ir)
     left, top, right, bottom =
@@ -380,6 +467,8 @@ private
     full: %w[meta hdlr pitm ipma ispe],
     last: %w[meta]
   )
+  private_constant :HEIF_WALKER
+
   def size_of_heif(ir)
     pitm = nil
     ipma = nil
@@ -390,11 +479,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'

data/spec/image_size/chunky_reader_spec.rb

@@ -2,7 +2,7 @@
 
 require 'rspec'
 
-require 'image_size/chunky_reader'
+require 'image_size'
 
 describe ImageSize::ChunkyReader do
   context :[] do

data/spec/image_size/seekable_io_reader_spec.rb

@@ -2,49 +2,44 @@
 
 require 'rspec'
 
-require 'image_size/seekable_io_reader'
+require 'image_size'
 
 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