image_size 3.0.2 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e594fe6ec7b9018dd68867a5feaf557c6c22e7ed667876089fcbe35d6f3104c
-  data.tar.gz: a221e99d54a933452712df549e2b8b05ceb85c407b27f482042d35c97dbb95c8
+  metadata.gz: f086d46fca698649fed0a23adca9dc67e1fa3317d9f3c209f1fe7f07fcd2cb6b
+  data.tar.gz: ff8f5243aadd37691eb7dabaa7e4b0d3b6fb212aba286a10d86165dc174eabff
 SHA512:
-  metadata.gz: dbc4b3ec562040c3316edfc7412110eec1eef87028100f156e155a65bb38bccba7199b1094daa5ddc62317229a0fbe7241af0ba2089adf6ee03ab7eb4d85c634
-  data.tar.gz: db58b0bee4cf294cf44ac5b4afe01c8cd0420b0155e220e378755081ca1a655adb1ac30695966f150b094c648befbd8fb96f31d9a835afbefe1bffbc7ce717b4
+  metadata.gz: 6ff23aa12846de6eaeb9a8ae02cde4a152f891e863056cf901732ef1c6cd1a580befab1cb62037feed500906901018cf8cdb64b63dd6538c07f0b84c5e8ce80e
+  data.tar.gz: fe6d488afbac72d4a8c16e3d1457c9ae3acf82b87ac9bd6df34e4077f0a0166c47862eac796f71e34084bb7c1314e49f79963eba41ad73de935232b2f2c35bd1

data/CHANGELOG.markdown

@@ -2,6 +2,15 @@
 
 ## unreleased
 
+## v3.2.0 (2022-11-03)
+
+* Support `EMF` images [#21](https://github.com/toy/image_size/pull/21) [@opoudjis](https://github.com/opoudjis)
+
+## v3.1.0 (2022-09-17)
+
+* Document experimental fetching from http server [#18](https://github.com/toy/image_size/issues/18) [@toy](https://github.com/toy)
+* Improve experimental fetching of image meta from http server by reading only required amount of data when server does not support range header [@toy](https://github.com/toy)
+
 ## v3.0.2 (2022-05-19)
 
 * Fix handling empty files [#20](https://github.com/toy/image_size/issues/20) [@toy](https://github.com/toy)
@@ -15,6 +24,7 @@
 * 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)
+* Experimental efficient fetching of image meta from http server supporting range [@toy](https://github.com/toy)
 
 ## v2.1.2 (2021-08-21)
 

data/README.markdown

@@ -1,10 +1,11 @@
 [![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)
+[![Rubocop](https://img.shields.io/github/workflow/status/toy/image_size/rubocop/master?label=rubocop&logo=rubocop)](https://github.com/toy/image_size/actions/workflows/rubocop.yml)
 
 # 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`.
+Formats: `apng`, `bmp`, `cur`, `emf`, `gif`, `ico`, `j2c`, `jp2`, `jpeg`, `jpx`, `mng`, `pam`, `pbm`, `pcx`, `pgm`, `png`, `ppm`, `psd`, `svg`, `swf`, `tiff`, `webp`, `xbm`, `xpm`.
 
 ## Installation
 
@@ -53,7 +54,7 @@ require 'image_size'
 image_size = ImageSize.new(ARGF)
 ```
 
-Works with `open-uri` if needed:
+Works with `open-uri`, see [experimental HTTP server interface below](#experimental-fetch-image-meta-from-http-server):
 
 ```ruby
 require 'image_size'
@@ -89,6 +90,55 @@ File.open('spec/images/jpeg/436x429.jpeg', 'rb') do |fh|
 end
 ```
 
+### Experimental: fetch image meta from HTTP server
+
+If server recognises Range header, only needed chunks will be fetched even for TIFF images, otherwise required amount
+of data will be fetched, in most cases first few kilobytes (TIFF images is an exception).
+
+```ruby
+require 'image_size'
+require 'image_size/uri_reader'
+
+url = 'http://upload.wikimedia.org/wikipedia/commons/b/b4/Mardin_1350660_1350692_33_images.jpg'
+p ImageSize.url(url).size
+```
+
+This interface is as fast as dedicated gem fastimage for images with meta information in the header:
+
+```ruby
+url = 'http://upload.wikimedia.org/wikipedia/commons/b/b4/Mardin_1350660_1350692_33_images.jpg'
+puts Benchmark.measure{ p FastImage.size(url) }
+```
+```
+[9545, 6623]
+  0.004176   0.001974   0.006150 (  0.282889)
+```
+```ruby
+puts Benchmark.measure{ p ImageSize.url(url).size }
+```
+```
+[9545, 6623]
+  0.005604   0.001406   0.007010 (  0.238629)
+```
+
+And considerably faster for images with meta information at the end of file:
+
+```ruby
+url = "https://upload.wikimedia.org/wikipedia/commons/c/c7/Curiosity%27s_Vehicle_System_Test_Bed_%28VSTB%29_Rover_%28PIA15876%29.tif"
+puts Benchmark.measure{ p FastImage.size(url) }
+```
+```
+[7360, 4912]
+  0.331284   0.247295   0.578579 (  6.027051)
+```
+```ruby
+puts Benchmark.measure{ p ImageSize.url(url).size }
+```
+```
+[7360, 4912]
+  0.006247   0.001045   0.007292 (  0.197631)
+```
+
 ## Licence
 
 This code is free to use under the terms of the [Ruby's licence](LICENSE.txt).

data/image_size.gemspec

@@ -2,9 +2,9 @@
 
 Gem::Specification.new do |s|
   s.name        = 'image_size'
-  s.version     = '3.0.2'
+  s.version     = '3.2.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.description = %q{Measure following file dimensions: apng, bmp, cur, emf, 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'

data/lib/image_size/uri_reader.rb

@@ -6,67 +6,103 @@ require 'image_size/chunky_reader'
 require 'net/https'
 require 'uri'
 
-# This is a hacky experiment and not part of public API
+# Experimental, not yet part of stable API
 #
-# It adds ability to fetch size of image from http server while downloading only
-# needed chunks if the server recognises Range header
+# It adds ability to fetch image meta from HTTP server while downloading only
+# needed chunks if the server recognises Range header, otherwise fetches only
+# required amount of data
 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
+  module URIReader # :nodoc:
+    module HTTPChunkyReader # :nodoc:
+      include ChunkyReader
 
-      @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 }
-      when Net::HTTPRequestedRangeNotSatisfiable
-        @body = ''
-      else
-        raise "Unexpected response: #{response}"
+      def chunk_range_header(i)
+        { 'Range' => "bytes=#{chunk_size * i}-#{(chunk_size * (i + 1)) - 1}" }
       end
     end
 
-    def [](offset, length)
-      if @body
+    class BodyReader # :nodoc:
+      include ChunkyReader
+
+      def initialize(response)
+        @body = String.new
+        @body_reader = response.to_enum(:read_body)
+      end
+
+      def [](offset, length)
+        if @body_reader
+          begin
+            @body << @body_reader.next while @body.length < offset + length
+          rescue StopIteration, IOError
+            @body_reader = nil
+          end
+        end
+
         @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
+    class RangeReader # :nodoc:
+      include HTTPChunkyReader
+
+      def initialize(http, request_uri, chunk0)
+        @http = http
+        @request_uri = request_uri
+        @chunks = { 0 => chunk0 }
       end
 
-      @chunks[i]
+      def chunk(i)
+        unless @chunks.key?(i)
+          response = @http.get(@request_uri, chunk_range_header(i))
+          case response
+          when Net::HTTPPartialContent
+            @chunks[i] = response.body
+          else
+            raise "Unexpected response: #{response}"
+          end
+        end
+
+        @chunks[i]
+      end
     end
 
-  private
+    class << self
+      include HTTPChunkyReader
+
+      def open(uri, max_redirects = 5)
+        http = nil
+        (max_redirects + 1).times do
+          unless 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
 
-    def request_chunk(i)
-      @http.get(@request_uri, 'Range' => "bytes=#{chunk_size * i}-#{(chunk_size * (i + 1)) - 1}")
+          response = http.request_get(uri.request_uri, chunk_range_header(0)) do |response_with_unread_body|
+            case response_with_unread_body
+            when Net::HTTPOK
+              return yield BodyReader.new(response_with_unread_body)
+            end
+          end
+
+          case response
+          when Net::HTTPRedirection
+            uri += response['location']
+          when Net::HTTPPartialContent
+            return yield RangeReader.new(http, uri.request_uri, response.body)
+          when Net::HTTPRequestedRangeNotSatisfiable
+            return yield StringReader.new('')
+          else
+            raise "Unexpected response: #{response}"
+          end
+        end
+
+        raise "Too many redirects: #{uri}"
+      ensure
+        http.finish if http.started?
+      end
     end
   end
 
@@ -74,7 +110,7 @@ class ImageSize
     class << self
       def open_with_uri(input, &block)
         if input.is_a?(URI)
-          yield URIReader.new(input)
+          URIReader.open(input, &block)
         else
           open_without_uri(input, &block)
         end

data/lib/image_size.rb

@@ -95,6 +95,7 @@ private
     when head[0, 4] == "\0\0\2\0"                                 then :cur
     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
     end
   end
 
@@ -374,4 +375,20 @@ private
   def size_of_j2c(ir)
     ir.unpack(8, 8, 'NN')
   end
+
+  EMF_UMAX = 256**4
+  EMF_SMAX = EMF_UMAX / 2
+
+  def size_of_emf(ir)
+    left, top, right, bottom =
+      if RUBY_VERSION < '1.9'
+        ir.unpack(24, 16, 'V*').map{ |u| u < EMF_SMAX ? u : u - EMF_UMAX }
+      else
+        ir.unpack(24, 16, 'L<*')
+      end
+    dpi = self.class.dpi
+    [right - left + 1, bottom - top + 1].map do |n|
+      (n.to_f * dpi / 2540).round
+    end
+  end
 end

data/spec/image_size/chunky_reader_spec.rb

@@ -56,9 +56,11 @@ describe ImageSize::ChunkyReader do
               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}"
+                                                  [
+                                                    "for offset #{offset} and length #{length}",
+                                                    "expected: #{data[offset, length].inspect}",
+                                                    "     got: #{reader[offset, length].inspect}",
+                                                  ].join("\n")
               end
             end
           end

data/spec/image_size_spec.rb

@@ -7,24 +7,36 @@ require 'image_size/uri_reader'
 
 require 'tempfile'
 require 'shellwords'
-require 'webrick'
+
+require 'test_server'
 
 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://127.0.0.1:#{@server.config[:Port]}/")
+    @server = TestServer.new
   end
 
   after :all do
-    @server.shutdown
-    @server_thread.join
+    @server.finish
+  end
+
+  def supported_formats
+    ImageSize.private_instance_methods.map{ |name| name[/\Asize_of_(.*)\z/, 1] }.compact.sort
+  end
+
+  describe 'README' do
+    let(:readme){ File.read('README.markdown') }
+
+    it 'lists all supported formats' do
+      expect(readme[/^Formats: .*$/]).to eq("Formats: #{supported_formats.map{ |format| "`#{format}`" }.join(', ')}.")
+    end
+  end
+
+  describe 'gemspec' do
+    let(:gemspec){ Gem::Specification.load('image_size.gemspec') }
+
+    it 'lists all supported formats in description' do
+      expect(gemspec.description).to eq("Measure following file dimensions: #{supported_formats.join(', ')}")
+    end
   end
 
   Dir['spec/**/*'].each do |path|
@@ -131,9 +143,54 @@ describe ImageSize do
       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)
+        let(:file_url){ @server.base_url + path }
+
+        context 'supporting range' do
+          context 'without redirects' do
+            it 'gets format and dimensions' do
+              image_size = ImageSize.url(file_url)
+              expect(image_size).to have_attributes(attributes)
+            end
+          end
+
+          context 'with redirects' do
+            it 'gets format and dimensions' do
+              image_size = ImageSize.url("#{file_url}?redirect=5")
+              expect(image_size).to have_attributes(attributes)
+            end
+          end
+
+          context 'with too many redirects' do
+            it 'gets format and dimensions' do
+              expect do
+                ImageSize.url("#{file_url}?redirect=6")
+              end.to raise_error(/Too many redirects/)
+            end
+          end
+        end
+
+        context 'not supporting range' do
+          context 'without redirects' do
+            it 'gets format and dimensions' do
+              image_size = ImageSize.url("#{file_url}?ignore_range")
+              expect(image_size).to have_attributes(attributes)
+            end
+          end
+
+          context 'with redirects' do
+            it 'gets format and dimensions' do
+              image_size = ImageSize.url("#{file_url}?ignore_range&redirect=5")
+              expect(image_size).to have_attributes(attributes)
+            end
+          end
+
+          context 'with too many redirects' do
+            it 'gets format and dimensions' do
+              expect do
+                ImageSize.url("#{file_url}?ignore_range&redirect=6")
+              end.to raise_error(/Too many redirects/)
+            end
+          end
         end
       end
     end

data/spec/test_server.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'webrick'
+
+class TestServer
+  attr_reader :base_url
+
+  def initialize(host = '127.0.0.1')
+    server_options = {
+      :Logger => WEBrick::Log.new(StringIO.new),
+      :AccessLog => [],
+      :BindAddress => host,
+      :Port => 0, # get the next available port
+      :DocumentRoot => '.',
+      :RequestCallback => proc do |req, res|
+        redirect = req.query['redirect'].to_i
+        if redirect > 0
+          res.set_redirect(
+            WEBrick::HTTPStatus::TemporaryRedirect,
+            [
+              req.request_uri.port == @base_url.port ? @second_url : @base_url,
+              req.request_uri.request_uri,
+              "?#{encode_www_form(req.query.merge('redirect' => redirect - 1))}",
+            ].inject(:+)
+          )
+        end
+
+        req.header.delete('range') if req.query['ignore_range']
+      end,
+    }
+
+    @server = WEBrick::HTTPServer.new(server_options)
+    @server.listen(host, 0) # listen on second port
+
+    @base_url = URI("http://#{host}:#{@server.listeners[0].addr[1]}/")
+    @second_url = URI("http://#{host}:#{@server.listeners[1].addr[1]}/")
+
+    @thread = Thread.new{ @server.start }
+  end
+
+  def finish
+    @server.shutdown
+    @thread.join
+  end
+
+private
+
+  if URI.respond_to?(:encode_www_form)
+    def encode_www_form(h)
+      URI.encode_www_form(h)
+    end
+  else
+    require 'cgi'
+
+    def encode_www_form(h)
+      h.map do |k, v|
+        "#{CGI.escape(k)}=#{CGI.escape(v.to_s)}"
+      end.join('&')
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: image_size
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.2.0
 platform: ruby
 authors:
 - Keisuke Minami
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-19 00:00:00.000000000 Z
+date: 2022-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -53,8 +53,9 @@ dependencies:
     - - "~>"
       - !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'
+description: 'Measure following file dimensions: apng, bmp, cur, emf, gif, ico, j2c,
+  jp2, jpeg, jpx, mng, pam, pbm, pcx, pgm, png, ppm, psd, svg, swf, tiff, webp, xbm,
+  xpm'
 email:
 executables: []
 extensions: []
@@ -86,6 +87,8 @@ files:
 - spec/images/bmp/v3-bottom2top.42x50.bmp
 - spec/images/bmp/v3-top2bottom.42x50.bmp
 - spec/images/cur/32x256.cur
+- spec/images/emf/74x77.emf
+- spec/images/emf/77x77.emf
 - spec/images/empty
 - spec/images/gif/668x481.gif
 - spec/images/ico/32x256.ico
@@ -120,13 +123,14 @@ files:
 - spec/images/xbm/crlf.16x32.xbm
 - spec/images/xpm/24x32.xpm
 - spec/images/xpm/crlf.24x32.xpm
+- spec/test_server.rb
 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/3.0.2
+  documentation_uri: https://www.rubydoc.info/gems/image_size/3.2.0
   source_code_uri: https://github.com/toy/image_size
 post_install_message:
 rdoc_options: []
@@ -156,6 +160,8 @@ test_files:
 - spec/images/bmp/v3-bottom2top.42x50.bmp
 - spec/images/bmp/v3-top2bottom.42x50.bmp
 - spec/images/cur/32x256.cur
+- spec/images/emf/74x77.emf
+- spec/images/emf/77x77.emf
 - spec/images/empty
 - spec/images/gif/668x481.gif
 - spec/images/ico/32x256.ico
@@ -190,3 +196,4 @@ test_files:
 - spec/images/xbm/crlf.16x32.xbm
 - spec/images/xpm/24x32.xpm
 - spec/images/xpm/crlf.24x32.xpm
+- spec/test_server.rb