image_size 2.0.2 → 3.0.0

data/README.markdown

@@ -1,10 +1,10 @@
-[![Gem Version](https://img.shields.io/gem/v/image_size.svg?style=flat)](https://rubygems.org/gems/image_size)
-[![Build Status](https://img.shields.io/travis/toy/image_size/master.svg?style=flat)](https://travis-ci.org/toy/image_size)
+[![Gem Version](https://img.shields.io/gem/v/image_size?logo=rubygems)](https://rubygems.org/gems/image_size)
+[![Build Status](https://img.shields.io/github/workflow/status/toy/image_size/check/master?logo=github)](https://github.com/toy/image_size/actions/workflows/check.yml)
 
 # image_size
 
-measure image size using pure Ruby
-formats: `apng`, `bmp`, `cur`, `gif`, `jpeg`, `ico`, `mng`, `pbm`, `pcx`, `pgm`, `png`, `ppm`, `psd`, `swf`, `tiff`, `xbm`, `xpm`, `webp`
+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
 
@@ -85,9 +91,7 @@ end
 
 ## Licence
 
-This code is free to use under the terms of the Ruby's licence.
+This code is free to use under the terms of the [Ruby's licence](LICENSE.txt).
 
-## Contact
-
-Original author: "Keisuke Minami": mailto:keisuke@rccn.com
-Further development by Ivan Kuchin https://github.com/toy/image_size
+Original author: Keisuke Minami <keisuke@rccn.com>.\
+Further development 2010-2021 Ivan Kuchin https://github.com/toy/image_size

data/image_size.gemspec

@@ -2,10 +2,10 @@
 
 Gem::Specification.new do |s|
   s.name        = 'image_size'
-  s.version     = '2.0.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, jpeg, ico, mng, pbm, pcx, pgm, png, ppm, psd, swf, tiff, xbm, xpm, webp}
-  s.homepage    = "http://github.com/toy/#{s.name}"
+  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}"
   s.authors     = ['Keisuke Minami', 'Ivan Kuchin']
   s.license     = 'Ruby'
 
@@ -22,7 +22,8 @@ Gem::Specification.new do |s|
   s.require_paths = %w[lib]
 
   s.add_development_dependency 'rspec', '~> 3.0'
-  if RUBY_VERSION >= '2.2'
-    s.add_development_dependency 'rubocop', '~> 0.59'
+  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