image_size 2.1.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e5bf43db03f3e3f62465528a32d65b65592240db8756ef759f17b6b2d0c1f14
-  data.tar.gz: 4b5cfe6468ba3208528c971ce0873760688dd6a59f170d20fe5dc2934a4ca5ff
+  metadata.gz: 44be96b790fd826a8e6471928ce381cda6a0269bb9a24d7111142b54ff1556bb
+  data.tar.gz: 494d270c18e0e9583ce226e53a478bf5829ce3823cc212c392dc933445962a89
 SHA512:
-  metadata.gz: 18e0d5c54eb5a89ec5412f7b8094fe154d02f609f0d1dc217881a9bde7236d35ac7a9fe3f4c0f82d33c57c35d9368ca0c03c411a3b2d4f09f174ed4633f7dbed
-  data.tar.gz: 4685c93339d37b5d4b59caa697885cad1bfff21c934f0e243abcb7814eb9262bd5ecfbe7f8fcc12e8bd207aa2a1711a5bfa5f764ee74e6ddf31a4b1e926f0744
+  metadata.gz: e33c991f5c78de857a38591d62b6b71f9c95693b0222bdfa7141b94a0359cf76f3e94e3cdf1c424e2935a8f1f397072473c00ac53d0656aeece5ff5e077466dc
+  data.tar.gz: aec5519f54c0dafcc0ae424703567276161ca1c5f53306134c3c3995642a67533d7196b1671e1c74158ffed604a90d2ef61f3e7f5d175246b935954b697afe5d

data/.github/workflows/check.yml

@@ -28,7 +28,36 @@ jobs:
       with:
         ruby-version: "${{ matrix.ruby }}"
         bundler-cache: true
-    - run: bundle exec rspec
+    - run: bundle exec rspec --format documentation
+  legacy:
+    runs-on: ubuntu-latest
+    container: ${{ matrix.container }}
+    strategy:
+      matrix:
+        container:
+        - rspec/ci:1.8.7
+        - rspec/ci:1.9.3
+      fail-fast: false
+    steps:
+    - uses: actions/checkout@v2
+    - run: bundle install
+    - run: bundle exec rspec --format documentation
+  windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        ruby:
+        - '2.6'
+        - '2.7'
+        - '3.0'
+      fail-fast: false
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: "${{ matrix.ruby }}"
+        bundler-cache: true
+    - run: bundle exec rspec --format documentation
   rubocop:
     runs-on: ubuntu-latest
     steps:

data/.rubocop.yml

@@ -15,6 +15,9 @@ Layout/CaseIndentation:
 Layout/EndAlignment:
   EnforcedStyleAlignWith: variable
 
+Layout/FirstHashElementIndentation:
+  EnforcedStyle: consistent
+
 Layout/LineLength:
   Max: 120
 
@@ -65,6 +68,9 @@ Style/HashTransformValues:
 Style/IfUnlessModifier:
   Enabled: false
 
+Style/NumericPredicate:
+  Enabled: false
+
 Style/ParallelAssignment:
   Enabled: false
 

data/CHANGELOG.markdown

@@ -2,6 +2,12 @@
 
 ## unreleased
 
+## v3.0.0 (2021-10-17)
+
+* Read only required chunks of data for files and seekable IOs [@toy](https://github.com/toy)
+* Raise `FormatError` whenever reading data returns less data than expected [#12](https://github.com/toy/image_size/issues/12) [@toy](https://github.com/toy)
+* Add `w`/`width` and `h`/`height` accessors to `Size` [@toy](https://github.com/toy)
+
 ## v2.1.2 (2021-08-21)
 
 * Fix for pcx on big endian systems by forcing reading dimensions in little endian byte order [#15](https://github.com/toy/image_size/issues/15) [#16](https://github.com/toy/image_size/pull/16) [@mtasaka](https://github.com/mtasaka)

data/Gemfile

@@ -3,3 +3,5 @@
 source 'https://rubygems.org'
 
 gemspec
+
+gem 'webrick' if RUBY_VERSION >= '3.0'

data/README.markdown

@@ -3,8 +3,8 @@
 
 # image_size
 
-measure image size using pure Ruby
-formats: `apng`, `bmp`, `cur`, `gif`, `ico`, `j2c`, `jp2`, `jpeg`, `jpx`, `mng`, `pam`, `pbm`, `pcx`, `pgm`, `png`, `ppm`, `psd`, `svg`, `swf`, `tiff`, `webp`, `xbm`, `xpm`
+Measure image size using pure Ruby.
+Formats: `apng`, `bmp`, `cur`, `gif`, `ico`, `j2c`, `jp2`, `jpeg`, `jpx`, `mng`, `pam`, `pbm`, `pcx`, `pgm`, `png`, `ppm`, `psd`, `svg`, `swf`, `tiff`, `webp`, `xbm`, `xpm`.
 
 ## Installation
 
@@ -23,20 +23,26 @@ gem 'image_size', '~> 2.0'
 ## Usage
 
 ```ruby
-image_size = ImageSize.path('spec/test.jpg')
+image_size = ImageSize.path('spec/images/jpeg/436x429.jpeg')
 
 image_size.format       #=> :jpec
-image_size.width        #=> 320
-image_size.height       #=> 240
-image_size.w            #=> 320
-image_size.h            #=> 240
-image_size.size         #=> [320, 240]
+image_size.width        #=> 436
+image_size.height       #=> 429
+image_size.w            #=> 436
+image_size.h            #=> 429
+image_size.size         #=> [436, 429]
+image_size.size.to_s    #=> "436x429"
+"#{image_size.size}"    #=> "436x429"
+image_size.size.width   #=> 436
+image_size.size.height  #=> 429
+image_size.size.w       #=> 436
+image_size.size.h       #=> 429
 ```
 
 Or using `IO` object:
 
 ```ruby
-image_size = File.open('spec/test.jpg', 'rb'){ |fh| ImageSize.new(fh) }
+image_size = File.open('spec/images/jpeg/436x429.jpeg', 'rb'){ |fh| ImageSize.new(fh) }
 ```
 
 Any object responding to `read` and `eof?`:
@@ -68,14 +74,14 @@ So rewind if needed before passing to `ImageSize` and/or rewind after passing to
 ```ruby
 require 'image_size'
 
-File.open('spec/test.jpg', 'rb') do |fh|
+File.open('spec/images/jpeg/436x429.jpeg', 'rb') do |fh|
   image_size = ImageSize.new(fh)
 
   fh.rewind
   data = fh.read
 end
 
-File.open('spec/test.jpg', 'rb') do |fh|
+File.open('spec/images/jpeg/436x429.jpeg', 'rb') do |fh|
   data = fh.read
   fh.rewind
 
@@ -88,4 +94,4 @@ end
 This code is free to use under the terms of the [Ruby's licence](LICENSE.txt).
 
 Original author: Keisuke Minami <keisuke@rccn.com>.\
-Further development 2010-2020 Ivan Kuchin https://github.com/toy/image_size
+Further development 2010-2021 Ivan Kuchin https://github.com/toy/image_size

data/image_size.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'image_size'
-  s.version     = '2.1.2'
+  s.version     = '3.0.0'
   s.summary     = %q{Measure image size using pure Ruby}
   s.description = %q{Measure following file dimensions: apng, bmp, cur, gif, ico, j2c, jp2, jpeg, jpx, mng, pam, pbm, pcx, pgm, png, ppm, psd, svg, swf, tiff, webp, xbm, xpm}
   s.homepage    = "https://github.com/toy/#{s.name}"
@@ -24,5 +24,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rspec', '~> 3.0'
   if RUBY_VERSION >= '2.4'
     s.add_development_dependency 'rubocop', '~> 1.0'
+    s.add_development_dependency 'rubocop-rspec', '~> 2.0'
   end
 end

data/lib/image_size/chunky_reader.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'image_size/reader'
+
+class ImageSize
+  module ChunkyReader # :nodoc:
+    include Reader
+
+    # Size of a chunk in which to read
+    def chunk_size
+      4096
+    end
+
+    # Including class should define method chunk that accepts the chunk number
+    # and returns a string of chunk_size length or shorter for last chunk, or
+    # nil for further chunks.
+    # Determines required chunks, takes parts of them to construct desired
+    # substring, behaves same as str[start, length] except start can't be
+    # negative.
+    def [](offset, length)
+      raise ArgumentError, "expected offset not to be negative, got #{offset}" if offset < 0
+      return if length < 0
+
+      first = offset / chunk_size
+      return unless (first_chunk = chunk(first))
+
+      last = (offset + length - 1) / chunk_size
+
+      if first >= last
+        first_chunk[offset - (first * chunk_size), length]
+      else
+        return unless (first_piece = first_chunk[offset - (first * chunk_size), chunk_size])
+
+        chunks = (first.succ...last).map{ |i| chunk(i) }.unshift(first_piece)
+
+        if (last_chunk = chunk(last))
+          chunks.push(last_chunk[0, offset + length - (last * chunk_size)])
+        end
+
+        chunks.join
+      end
+    end
+  end
+end

data/lib/image_size/reader.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'stringio'
+
+class ImageSize
+  module Reader # :nodoc:
+    class << self
+      def open(input)
+        case
+        when input.is_a?(String)
+          yield StringReader.new(input)
+        when input.is_a?(StringIO)
+          yield StringReader.new(input.string)
+        when input.respond_to?(:read) && input.respond_to?(:eof?)
+          yield for_io(input)
+        when input.is_a?(Pathname)
+          input.open('rb'){ |f| yield for_io(f) }
+        else
+          raise ArgumentError, "expected data as String or an object responding to read and eof?, got #{input.class}"
+        end
+      end
+
+    private
+
+      def for_io(io)
+        if io.respond_to?(:stat) && !io.stat.file?
+          StreamIOReader.new(io)
+        else
+          begin
+            io.seek(0, IO::SEEK_CUR)
+            SeekableIOReader.new(io)
+          rescue Errno::ESPIPE, Errno::EINVAL
+            StreamIOReader.new(io)
+          end
+        end
+      end
+    end
+
+    def fetch(offset, length)
+      chunk = self[offset, length]
+
+      unless chunk && chunk.length == length
+        raise FormatError, "Expected #{length} bytes at offset #{offset}, got #{chunk.inspect}"
+      end
+
+      chunk
+    end
+
+    def unpack(offset, length, format)
+      fetch(offset, length).unpack(format)
+    end
+
+    if ''.respond_to?(:unpack1)
+      def unpack1(offset, length, format)
+        fetch(offset, length).unpack1(format)
+      end
+    else
+      def unpack1(offset, length, format)
+        fetch(offset, length).unpack(format)[0]
+      end
+    end
+  end
+end

data/lib/image_size/seekable_io_reader.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'image_size/chunky_reader'
+
+class ImageSize
+  class SeekableIOReader # :nodoc:
+    include ChunkyReader
+
+    def initialize(io)
+      @io = io
+      @pos = 0
+      @chunks = {}
+    end
+
+  private
+
+    def chunk(i)
+      unless @chunks.key?(i)
+        @io.seek((chunk_size * i) - @pos, IO::SEEK_CUR)
+        data = @io.read(chunk_size)
+        @pos += data.length
+        @chunks[i] = data
+      end
+
+      @chunks[i]
+    end
+  end
+end

data/lib/image_size/stream_io_reader.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'image_size/chunky_reader'
+
+class ImageSize
+  class StreamIOReader # :nodoc:
+    include ChunkyReader
+
+    def initialize(io)
+      @io = io
+      @chunks = []
+    end
+
+  private
+
+    def chunk(i)
+      @chunks << @io.read(chunk_size) while i >= @chunks.length && !@io.eof?
+
+      @chunks[i]
+    end
+  end
+end

data/lib/image_size/string_reader.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'image_size/reader'
+
+class ImageSize
+  class StringReader # :nodoc:
+    include Reader
+
+    def initialize(string)
+      @string = if string.respond_to?(:encoding) && string.encoding.name != 'ASCII-8BIT'
+        string.dup.force_encoding('ASCII-8BIT')
+      else
+        string
+      end
+    end
+
+    def [](offset, length)
+      @string[offset, length]
+    end
+  end
+end

data/lib/image_size/uri_reader.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'image_size/reader'
+require 'image_size/chunky_reader'
+
+require 'net/https'
+require 'uri'
+
+# This is a hacky experiment and not part of public API
+#
+# It adds ability to fetch size of image from http server while downloading only
+# needed chunks if the server recognises Range header
+class ImageSize
+  class URIReader # :nodoc:
+    include ChunkyReader
+
+    def initialize(uri, redirects = 5)
+      if !@http || @http.address != uri.host || @http.port != uri.port
+        @http.finish if @http
+        @http = Net::HTTP.new(uri.host, uri.port)
+        @http.use_ssl = true if uri.scheme == 'https'
+        @http.start
+      end
+
+      @request_uri = uri.request_uri
+      response = request_chunk(0)
+
+      case response
+      when Net::HTTPRedirection
+        raise "Too many redirects: #{response['location']}" unless redirects > 0
+
+        initialize(uri + response['location'], redirects - 1)
+      when Net::HTTPOK
+        @body = response.body
+      when Net::HTTPPartialContent
+        @chunks = { 0 => response.body }
+      else
+        raise "Unexpected response: #{response}"
+      end
+    end
+
+    def [](offset, length)
+      if @body
+        @body[offset, length]
+      else
+        super
+      end
+    end
+
+    def chunk(i)
+      unless @chunks.key?(i)
+        response = request_chunk(i)
+        case response
+        when Net::HTTPPartialContent
+          @chunks[i] = response.body
+        else
+          raise "Unexpected response: #{response}"
+        end
+      end
+
+      @chunks[i]
+    end
+
+  private
+
+    def request_chunk(i)
+      @http.get(@request_uri, 'Range' => "bytes=#{chunk_size * i}-#{(chunk_size * (i + 1)) - 1}")
+    end
+  end
+
+  module Reader # :nodoc:
+    class << self
+      def open_with_uri(input, &block)
+        if input.is_a?(URI)
+          yield URIReader.new(input)
+        else
+          open_without_uri(input, &block)
+        end
+      end
+      alias_method :open_without_uri, :open
+      alias_method :open, :open_with_uri
+    end
+  end
+
+  def self.url(url)
+    new(url.is_a?(URI) ? url : URI(url))
+  end
+end

data/lib/image_size.rb

@@ -1,7 +1,10 @@
 # encoding: BINARY
 # frozen_string_literal: true
 
-require 'stringio'
+require 'image_size/reader'
+require 'image_size/seekable_io_reader'
+require 'image_size/stream_io_reader'
+require 'image_size/string_reader'
 
 # Determine image format and size
 class ImageSize
@@ -13,38 +16,23 @@ class ImageSize
     def to_s
       join('x')
     end
-  end
-
-  class ImageReader # :nodoc:
-    attr_reader :data
 
-    def initialize(data_or_io)
-      @io = if data_or_io.is_a?(String)
-        StringIO.new(data_or_io)
-      elsif data_or_io.respond_to?(:read) && data_or_io.respond_to?(:eof?)
-        data_or_io
-      else
-        raise ArgumentError, "expected data as String or an object responding to read and eof?, got #{data_or_io.class}"
-      end
-      @data = String.new # not frozen
+    # get first element
+    def width
+      self[0]
     end
+    alias_method :w, :width
 
-    CHUNK = 1024
-    def [](offset, length)
-      while !@io.eof? && @data.length < offset + length
-        data = @io.read(CHUNK)
-        break unless data
-
-        data.force_encoding(@data.encoding) if data.respond_to?(:encoding)
-        @data << data
-      end
-      @data[offset, length]
+    # get second element
+    def height
+      self[1]
     end
+    alias_method :h, :height
   end
 
   # Given path to image finds its format, width and height
   def self.path(path)
-    File.open(path, 'rb'){ |f| new(f) }
+    new(Pathname.new(path))
   end
 
   # Used for svg
@@ -59,11 +47,10 @@ class ImageSize
 
   # Given image as any class responding to read and eof? or data as String, finds its format and dimensions
   def initialize(data)
-    ir = ImageReader.new(data)
-    @format = detect_format(ir)
-    return unless @format
-
-    @width, @height = send("size_of_#{@format}", ir)
+    Reader.open(data) do |ir|
+      @format = detect_format(ir)
+      @width, @height = send("size_of_#{@format}", ir) if @format
+    end
   end
 
   # Image format
@@ -100,7 +87,7 @@ private
     when head =~ %r{/\* XPM \*/}                                  then :xpm
     when head[0, 4] == '8BPS'                                     then :psd
     when head[0, 3] =~ /[FC]WS/                                   then :swf
-    when head =~ SVG_R || (head =~ XML_R && ir[0, 4096][SVG_R])   then :svg
+    when head =~ SVG_R || (head =~ XML_R && ir[0, 4096] =~ SVG_R) then :svg
     when head[0, 2] =~ /\n[\0-\5]/                                then :pcx
     when head[0, 12] =~ /RIFF(?m:....)WEBP/                       then :webp
     when head[0, 4] == "\0\0\1\0"                                 then :ico
@@ -117,7 +104,7 @@ private
       break if ['IDAT', 'IEND', nil].include?(type)
       return :apng if type == 'acTL'
 
-      length = ir[offset, 4].unpack('N')[0]
+      length = ir.unpack1(offset, 4, 'N')
       offset += 8 + length + 4
     end
     :png
@@ -144,7 +131,7 @@ private
   end
 
   def size_of_gif(ir)
-    ir[6, 4].unpack('vv')
+    ir.unpack(6, 4, 'vv')
   end
 
   def size_of_mng(ir)
@@ -152,7 +139,7 @@ private
       raise FormatError, 'MHDR not in place for MNG'
     end
 
-    ir[16, 8].unpack('NN')
+    ir.unpack(16, 8, 'NN')
   end
 
   def size_of_png(ir)
@@ -160,7 +147,7 @@ private
       raise FormatError, 'IHDR not in place for PNG'
     end
 
-    ir[16, 8].unpack('NN')
+    ir.unpack(16, 8, 'NN')
   end
   alias_method :size_of_apng, :size_of_png
 
@@ -178,11 +165,11 @@ private
       offset += 1 until section_marker != ir[offset + 1, 1]
       raise FormatError, 'EOF in JPEG' if ir[offset, 1].nil?
 
-      _marker, code, length = ir[offset, 4].unpack('aCn')
+      code, length = ir.unpack(offset, 4, 'xCn')
       offset += 4
 
       if JPEG_CODE_CHECK.include?(code)
-        return ir[offset + 1, 4].unpack('nn').reverse
+        return ir.unpack(offset + 1, 4, 'nn').reverse
       end
 
       offset += length - 2
@@ -190,11 +177,11 @@ private
   end
 
   def size_of_bmp(ir)
-    header_size = ir[14, 4].unpack('V')[0]
+    header_size = ir.unpack1(14, 4, 'V')
     if header_size == 12
-      ir[18, 4].unpack('vv')
+      ir.unpack(18, 4, 'vv')
     else
-      ir[18, 8].unpack('VV').map do |n|
+      ir.unpack(18, 8, 'VV').map do |n|
         if n > 0x7fff_ffff
           0x1_0000_0000 - n # absolute value of converted to signed
         else
@@ -216,7 +203,7 @@ private
   def size_of_pam(ir)
     width = height = nil
     offset = 3
-    loop do
+    until width && height
       if ir[offset, 1] == '#'
         offset += 1 until ["\n", '', nil].include?(ir[offset, 1])
         offset += 1
@@ -235,7 +222,6 @@ private
           raise FormatError, "Unexpected data in PAM header: #{chunk.inspect}"
         end
         offset += $&.length
-        break if width && height
       end
     end
     [width, height]
@@ -259,23 +245,23 @@ private
   end
 
   def size_of_psd(ir)
-    ir[14, 8].unpack('NN').reverse
+    ir.unpack(14, 8, 'NN').reverse
   end
 
   def size_of_tiff(ir)
-    endian2b = ir[0, 4] == "II*\000" ? 'v' : 'n'
+    endian2b = ir.fetch(0, 4) == "II*\000" ? 'v' : 'n'
     endian4b = endian2b.upcase
     packspec = [nil, 'C', nil, endian2b, endian4b, nil, 'c', nil, endian2b, endian4b]
 
-    offset = ir[4, 4].unpack(endian4b)[0]
-    num_dirent = ir[offset, 2].unpack(endian2b)[0]
+    offset = ir.unpack1(4, 4, endian4b)
+    num_dirent = ir.unpack1(offset, 2, endian2b)
     offset += 2
     num_dirent = offset + (num_dirent * 12)
 
     width = height = nil
     until width && height
-      ifd = ir[offset, 12]
-      raise FormatError, 'Reached end of directory entries in TIFF' if ifd.nil? || offset > num_dirent
+      ifd = ir.fetch(offset, 12)
+      raise FormatError, 'Reached end of directory entries in TIFF' if offset > num_dirent
 
       tag, type = ifd.unpack(endian2b * 2)
       offset += 12
@@ -294,14 +280,14 @@ private
   end
 
   def size_of_pcx(ir)
-    parts = ir[4, 8].unpack('v4')
+    parts = ir.unpack(4, 8, 'v4')
     [parts[2] - parts[0] + 1, parts[3] - parts[1] + 1]
   end
 
   def size_of_swf(ir)
-    value_bit_length = ir[8, 1].unpack('B5').first.to_i(2)
-    bit_length = 5 + value_bit_length * 4
-    rect_bits = ir[8, bit_length / 8 + 1].unpack("B#{bit_length}").first
+    value_bit_length = ir.unpack1(8, 1, 'B5').to_i(2)
+    bit_length = 5 + (value_bit_length * 4)
+    rect_bits = ir.unpack1(8, (bit_length / 8) + 1, "B#{bit_length}")
     values = rect_bits[5..-1].unpack("a#{value_bit_length}" * 4).map{ |bits| bits.to_i(2) }
     x_min, x_max, y_min, y_max = values
     [(x_max - x_min) / 20, (y_max - y_min) / 20]
@@ -309,7 +295,8 @@ private
 
   def size_of_svg(ir)
     attributes = {}
-    ir.data[SVG_R, 1].scan(/(\S+)=(?:'([^']*)'|"([^"]*)"|([^'"\s]*))/) do |name, v0, v1, v2|
+    svg_tag = ir[0, 1024][SVG_R, 1] || ir[0, 4096][SVG_R, 1]
+    svg_tag.scan(/(\S+)=(?:'([^']*)'|"([^"]*)"|([^'"\s]*))/) do |name, v0, v1, v2|
       attributes[name] = v0 || v1 || v2
     end
     dpi = self.class.dpi
@@ -330,20 +317,20 @@ private
   end
 
   def size_of_ico(ir)
-    ir[6, 2].unpack('CC').map{ |v| v.zero? ? 256 : v }
+    ir.unpack(6, 2, 'CC').map{ |v| v.zero? ? 256 : v }
   end
   alias_method :size_of_cur, :size_of_ico
 
   def size_of_webp(ir)
-    case ir[12, 4]
+    case ir.fetch(12, 4)
     when 'VP8 '
-      ir[26, 4].unpack('vv').map{ |v| v & 0x3fff }
+      ir.unpack(26, 4, 'vv').map{ |v| v & 0x3fff }
     when 'VP8L'
-      n = ir[21, 4].unpack('V')[0]
-      [(n & 0x3fff) + 1, (n >> 14 & 0x3fff) + 1]
+      n = ir.unpack1(21, 4, 'V')
+      [(n & 0x3fff) + 1, ((n >> 14) & 0x3fff) + 1]
     when 'VP8X'
-      w16, w8, h16, h8 = ir[24, 6].unpack('vCvC')
-      [(w16 | w8 << 16) + 1, (h16 | h8 << 16) + 1]
+      w16, w8, h16, h8 = ir.unpack(24, 6, 'vCvC')
+      [(w16 | (w8 << 16)) + 1, (h16 | (h8 << 16)) + 1]
     end
   end
 
@@ -355,13 +342,13 @@ private
       break if stop && offset >= stop
       break if ir[offset, 4] == '' || ir[offset, 4].nil?
 
-      size = ir[offset, 4].unpack('N')[0]
-      type = ir[offset + 4, 4]
+      size = ir.unpack1(offset, 4, 'N')
+      type = ir.fetch(offset + 4, 4)
 
       data_offset = 8
       case size
       when 1
-        size = ir[offset, 8].unpack('Q>')[0]
+        size = ir.unpack1(offset, 8, 'Q>')
         data_offset = 16
         raise FormatError, "Unexpected xl-box size #{size}" if (1..15).include?(size)
       when 2..7
@@ -373,7 +360,7 @@ private
         offset += data_offset
         in_header = true
       elsif in_header && type == 'ihdr'
-        return ir[offset + data_offset, 8].unpack('NN').reverse
+        return ir.unpack(offset + data_offset, 8, 'NN').reverse
       else
         break if size.zero? # box to the end of file
 
@@ -384,6 +371,6 @@ private
   alias_method :size_of_jpx, :size_of_jp2
 
   def size_of_j2c(ir)
-    ir[8, 8].unpack('NN')
+    ir.unpack(8, 8, 'NN')
   end
 end

data/spec/image_size/chunky_reader_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'rspec'
+
+require 'image_size/chunky_reader'
+
+describe ImageSize::ChunkyReader do
+  context :[] do
+    test_reader = Class.new do
+      include ImageSize::ChunkyReader
+
+      def initialize(string)
+        @string = string
+      end
+
+    private
+
+      def chunk(i)
+        @string[i * chunk_size, chunk_size]
+      end
+    end
+
+    custom_chunk_size_reader = Class.new(test_reader) do
+      def chunk_size
+        100
+      end
+    end
+
+    {
+      'empty string' => '',
+      'a bit of data' => 'foo bar baz',
+      'a lot of data' => File.open('GPL', 'rb', &:read),
+    }.each do |data_description, data|
+      {
+        'default' => test_reader.new(data),
+        'custom' => custom_chunk_size_reader.new(data),
+      }.each do |chunk_size_description, reader|
+        context "for #{data_description} using reader with #{chunk_size_description} chunk size" do
+          it 'raises ArgumentError for negative offset' do
+            [-1, 0, 1, 100].each do |length|
+              expect{ reader[-1, length] }.to raise_exception(ArgumentError)
+            end
+          end
+
+          it 'behaves same as fetching a string for any offset and length' do
+            full_chunks = data.length / reader.chunk_size
+            offsets = [0, 1, full_chunks - 1, full_chunks, full_chunks + 1].map do |i|
+              [-1, 0, 1].map do |add|
+                (i * reader.chunk_size) + add
+              end
+            end.flatten
+
+            offsets.each do |offset|
+              next if offset < 0
+
+              offsets.each do |offset_b|
+                length = offset_b - offset
+                expect(reader[offset, length]).to eq(data[offset, length]),
+                                                  "for offset #{offset} and length #{length}\n"\
+                                                  "expected: #{data[offset, length].inspect}\n"\
+                                                  "     got: #{reader[offset, length].inspect}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/image_size_spec.rb

@@ -1,13 +1,35 @@
 # frozen_string_literal: true
 
 require 'rspec'
+
 require 'image_size'
+require 'image_size/uri_reader'
+
 require 'tempfile'
+require 'shellwords'
+require 'webrick'
 
 describe ImageSize do
+  before :all do
+    @server = WEBrick::HTTPServer.new({
+      :Logger => WEBrick::Log.new(StringIO.new),
+      :AccessLog => [],
+      :BindAddress => '127.0.0.1',
+      :Port => 0, # get the next available port
+      :DocumentRoot => '.',
+    })
+    @server_thread = Thread.new{ @server.start }
+    @server_base_url = URI("http://localhost:#{@server.config[:Port]}/")
+  end
+
+  after :all do
+    @server.shutdown
+    @server_thread.join
+  end
+
   max_filesize = 16_384
 
-  (Dir['spec/images/*/*.*'] + [__FILE__]).each do |path|
+  (Dir['spec/images/*/*.*'] + [__FILE__[%r{spec/.+?\z}]]).each do |path|
     filesize = File.size(path)
     warn "#{path} is too big #{filesize} (max #{max_filesize})" if filesize > max_filesize
 
@@ -50,13 +72,22 @@ describe ImageSize do
         end
       end
 
+      context 'given as unseekable IO' do
+        it 'gets format and dimensions' do
+          IO.popen(%W[cat #{path}].shelljoin, 'rb') do |io|
+            image_size = ImageSize.new(io)
+            expect(image_size).to have_attributes(attributes)
+            expect(io).not_to be_closed
+          end
+        end
+      end
+
       context 'given as StringIO' do
         it 'gets format and dimensions' do
           io = StringIO.new(file_data)
           image_size = ImageSize.new(io)
           expect(image_size).to have_attributes(attributes)
           expect(io).not_to be_closed
-          expect(io.pos).to_not be_zero
           io.rewind
           expect(io.read).to eq(file_data)
         end
@@ -84,6 +115,13 @@ describe ImageSize do
           expect(image_size).to have_attributes(attributes)
         end
       end
+
+      context 'fetching from webserver' do
+        it 'gets format and dimensions' do
+          image_size = ImageSize.url(@server_base_url + path)
+          expect(image_size).to have_attributes(attributes)
+        end
+      end
     end
   end
 

data/spec/images/.gitattributes

@@ -0,0 +1 @@
+* -text

data/spec/images/svg/crlf.72x100.svg

@@ -0,0 +1,3 @@
+<svg width="1in" height="100" xmlns="http://www.w3.org/2000/svg">
+	<circle cx="36" cy="50" r="30" stroke="black" stroke-width="10" fill="red" />
+</svg>

data/spec/images/svg/long.72x100.svg

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!--[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]-->
+<!--[   [[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]   ]-->
+<!--[   [   [[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]   ]   ]-->
+<!--[   [   [   [[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]   ]   ]   ]-->
+<!--[   [   [   [   [[[[[[[[[[[[]]]]]]]]]]]]   ]   ]   ]   ]-->
+<!--[   [   [   [   [   [[[[[[[[]]]]]]]]   ]   ]   ]   ]   ]-->
+<!--[   [   [   [   [   [   [[[[]]]]   ]   ]   ]   ]   ]   ]-->
+<!--[   [   [   [   [   [   [      ]   ]   ]   ]   ]   ]   ]-->
+<!--[   [   [   [   [   [   [      ]   ]   ]   ]   ]   ]   ]-->
+<!--[   [   [   [   [   [   [[[[]]]]   ]   ]   ]   ]   ]   ]-->
+<!--[   [   [   [   [   [[[[[[[[]]]]]]]]   ]   ]   ]   ]   ]-->
+<!--[   [   [   [   [[[[[[[[[[[[]]]]]]]]]]]]   ]   ]   ]   ]-->
+<!--[   [   [   [[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]   ]   ]   ]-->
+<!--[   [   [[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]   ]   ]-->
+<!--[   [[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]   ]-->
+<!--[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]-->
+<svg width="1in" height="100" xmlns="http://www.w3.org/2000/svg">
+	<circle cx="36" cy="50" r="30" stroke="black" stroke-width="10" fill="red" />
+</svg>

data/spec/images/svg/long.crlf.72x100.svg

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!--[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]-->
+<!--[   [[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]   ]-->
+<!--[   [   [[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]   ]   ]-->
+<!--[   [   [   [[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]   ]   ]   ]-->
+<!--[   [   [   [   [[[[[[[[[[[[]]]]]]]]]]]]   ]   ]   ]   ]-->
+<!--[   [   [   [   [   [[[[[[[[]]]]]]]]   ]   ]   ]   ]   ]-->
+<!--[   [   [   [   [   [   [[[[]]]]   ]   ]   ]   ]   ]   ]-->
+<!--[   [   [   [   [   [   [      ]   ]   ]   ]   ]   ]   ]-->
+<!--[   [   [   [   [   [   [      ]   ]   ]   ]   ]   ]   ]-->
+<!--[   [   [   [   [   [   [[[[]]]]   ]   ]   ]   ]   ]   ]-->
+<!--[   [   [   [   [   [[[[[[[[]]]]]]]]   ]   ]   ]   ]   ]-->
+<!--[   [   [   [   [[[[[[[[[[[[]]]]]]]]]]]]   ]   ]   ]   ]-->
+<!--[   [   [   [[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]   ]   ]   ]-->
+<!--[   [   [[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]   ]   ]-->
+<!--[   [[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]   ]-->
+<!--[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]-->
+<svg width="1in" height="100" xmlns="http://www.w3.org/2000/svg">
+	<circle cx="36" cy="50" r="30" stroke="black" stroke-width="10" fill="red" />
+</svg>

data/spec/images/xbm/crlf.16x32.xbm

@@ -0,0 +1,11 @@
+#define cursor_width 16
+#define cursor_height 32
+static unsigned char cursor_bits[] = {
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x84, 0x10,
+  0xe8, 0x0b, 0x90, 0x04, 0xa8, 0x0a, 0x88, 0x08,
+  0xfe, 0x3f, 0x88, 0x08, 0xa8, 0x0a, 0x90, 0x04,
+  0xe8, 0x0b, 0x84, 0x10, 0x80, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

data/spec/images/xpm/crlf.24x32.xpm

@@ -0,0 +1,40 @@
+/* XPM */
+static char *test2[] = {
+/* columns rows colors chars-per-pixel */
+"24 32 2 1 ",
+"  c red",
+". c white",
+/* pixels */
+"........................",
+"........................",
+"........................",
+"........................",
+"........................",
+"........................",
+"..  ..................  ",
+"..   ................   ",
+"...   ..............   .",
+"....   ............   ..",
+".....   ..........   ...",
+"......   ........   ....",
+".......   ......   .....",
+"........   ....   ......",
+".........   ..   .......",
+"..........      ........",
+"...........    .........",
+"............   .........",
+"...........     ........",
+"..........   .   .......",
+".........   ...   ......",
+"........   .....   .....",
+".......   .......   ....",
+"......   .........   ...",
+".....   ...........   ..",
+"....   .............   .",
+"...   ...............   ",
+"..   .................  ",
+"..  ................... ",
+"........................",
+"........................",
+"........................"
+};

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: image_size
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Keisuke Minami
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-21 00:00:00.000000000 Z
+date: 2021-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -39,6 +39,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: 'Measure following file dimensions: apng, bmp, cur, gif, ico, j2c, jp2,
   jpeg, jpx, mng, pam, pbm, pcx, pgm, png, ppm, psd, svg, swf, tiff, webp, xbm, xpm'
 email:
@@ -57,7 +71,15 @@ files:
 - README.markdown
 - image_size.gemspec
 - lib/image_size.rb
+- lib/image_size/chunky_reader.rb
+- lib/image_size/reader.rb
+- lib/image_size/seekable_io_reader.rb
+- lib/image_size/stream_io_reader.rb
+- lib/image_size/string_reader.rb
+- lib/image_size/uri_reader.rb
+- spec/image_size/chunky_reader_spec.rb
 - spec/image_size_spec.rb
+- spec/images/.gitattributes
 - spec/images/bmp/v2.42x50.bmp
 - spec/images/bmp/v3-bottom2top.42x50.bmp
 - spec/images/bmp/v3-top2bottom.42x50.bmp
@@ -82,6 +104,9 @@ files:
 - spec/images/pnm/ascii.22x25.ppm
 - spec/images/psd/16x20.psd
 - spec/images/svg/72x100.svg
+- spec/images/svg/crlf.72x100.svg
+- spec/images/svg/long.72x100.svg
+- spec/images/svg/long.crlf.72x100.svg
 - spec/images/swf/450x200.swf
 - spec/images/tiff/big-endian.68x49.tiff
 - spec/images/tiff/little-endian.40x68.tiff
@@ -89,14 +114,16 @@ files:
 - spec/images/webp/lossless.16x32.webp
 - spec/images/webp/lossy.16x32.webp
 - spec/images/xbm/16x32.xbm
+- spec/images/xbm/crlf.16x32.xbm
 - spec/images/xpm/24x32.xpm
+- spec/images/xpm/crlf.24x32.xpm
 homepage: https://github.com/toy/image_size
 licenses:
 - Ruby
 metadata:
   bug_tracker_uri: https://github.com/toy/image_size/issues
   changelog_uri: https://github.com/toy/image_size/blob/master/CHANGELOG.markdown
-  documentation_uri: https://www.rubydoc.info/gems/image_size/2.1.2
+  documentation_uri: https://www.rubydoc.info/gems/image_size/3.0.0
   source_code_uri: https://github.com/toy/image_size
 post_install_message:
 rdoc_options: []
@@ -113,12 +140,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.16
+rubygems_version: 3.2.29
 signing_key:
 specification_version: 4
 summary: Measure image size using pure Ruby
 test_files:
+- spec/image_size/chunky_reader_spec.rb
 - spec/image_size_spec.rb
+- spec/images/.gitattributes
 - spec/images/bmp/v2.42x50.bmp
 - spec/images/bmp/v3-bottom2top.42x50.bmp
 - spec/images/bmp/v3-top2bottom.42x50.bmp
@@ -143,6 +172,9 @@ test_files:
 - spec/images/pnm/ascii.22x25.ppm
 - spec/images/psd/16x20.psd
 - spec/images/svg/72x100.svg
+- spec/images/svg/crlf.72x100.svg
+- spec/images/svg/long.72x100.svg
+- spec/images/svg/long.crlf.72x100.svg
 - spec/images/swf/450x200.swf
 - spec/images/tiff/big-endian.68x49.tiff
 - spec/images/tiff/little-endian.40x68.tiff
@@ -150,4 +182,6 @@ test_files:
 - spec/images/webp/lossless.16x32.webp
 - spec/images/webp/lossy.16x32.webp
 - spec/images/xbm/16x32.xbm
+- spec/images/xbm/crlf.16x32.xbm
 - spec/images/xpm/24x32.xpm
+- spec/images/xpm/crlf.24x32.xpm