fastimage 2.1.0 → 2.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8bdd1b1858b1101956c8d27e85509ad1c68a436b
-  data.tar.gz: 54021e4718ed2bf2480dd7972b59a8b6b711061c
+SHA256:
+  metadata.gz: 074e776db55bfd4766292bca262afc562d4d38d07d86f56f1299a666b4dc3e30
+  data.tar.gz: 7e079013cbd7802773119a5a6b7f25377e2878c1afbeb610c68d8a8a069ad0a1
 SHA512:
-  metadata.gz: cf0bfcba525fbacbb09919754faf51e3702bdfba09430601db181485e5626949a0f6ed8797a34e37e1f13d19100fe4bf020e6f3ef7c77aad40efe544f7f3007d
-  data.tar.gz: bc307c6eda1000ad5a60be2bcfd98b18fa7bb33faf4bbf4db20c5fa4db3cb3653b55f39dba1653e83d0a8a8d3ec33ffe3a20da434d539993ae3b3447e8f3dea4
+  metadata.gz: 4c82693c20723bc22b41e9839104097b0cb435c392e8ddd19edff93aeaa1802f3319c6ad49f1b82ba3926bd1bdcc5e04870d02401ff20e745e61d26a81473c6b
+  data.tar.gz: 230fbfd667aab5c59ce7bc53909454d2d9134fdb3c6705173d5df264a3c8a36df2d879c959df1ab4662d5e216a554ada7ba482ba3e0872b9c000d087c91e5b29

data/README.textile

@@ -1,5 +1,5 @@
 !https://img.shields.io/gem/dt/fastimage.svg!:https://rubygems.org/gems/fastimage
-!https://travis-ci.org/sdsykes/fastimage.png?branch=master!:https://travis-ci.org/sdsykes/fastimage
+!https://travis-ci.org/sdsykes/fastimage.svg?branch=master!:https://travis-ci.org/sdsykes/fastimage
 
 h1. FastImage
 
@@ -92,6 +92,10 @@ h2. Documentation
 
 "http://sdsykes.github.io/fastimage/rdoc/FastImage.html":http://sdsykes.github.io/fastimage/rdoc/FastImage.html
 
+h2. Maintainer
+
+FastImage is maintained by Stephen Sykes (@sdsykes). Support this project by using "LibPixel":https://libpixel.com cloud based image resizing and processing service.
+
 h2. Benchmark
 
 It's way faster than conventional methods (for example the image_size gem) for most types of file when fetching over the wire.
@@ -128,7 +132,7 @@ h2. Tests
 
 You'll need to @gem install fakeweb@ and possibly also  @gem install test-unit@ to be able to run the tests.
 
-bc.. $ ruby test.rb
+bc.. $ ruby test/test.rb
 Run options:
 
 # Running tests:
@@ -151,6 +155,8 @@ h2. FastImage in other languages
 * "PHP by tommoor":https://github.com/tommoor/fastimage
 * "Node.js by ShogunPanda":https://github.com/ShogunPanda/fastimage
 * "Objective C by kylehickinson":https://github.com/kylehickinson/FastImage
+* "Android by qstumn":https://github.com/qstumn/FastImageSize
+* "Flutter by ky1vstar":https://github.com/ky1vstar/fastimage.dart
 
 h2. Licence
 

data/lib/fastimage.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # coding: ASCII-8BIT
 
 # FastImage finds the size or type of an image given its uri.
@@ -69,7 +70,7 @@ if RUBY_VERSION < "2.2"
 end
 
 class FastImage
-  attr_reader :size, :type, :content_length, :orientation
+  attr_reader :size, :type, :content_length, :orientation, :animated
 
   attr_reader :bytes_read
 
@@ -88,6 +89,8 @@ class FastImage
 
   LocalFileChunkSize = 256 unless const_defined?(:LocalFileChunkSize)
 
+  SUPPORTED_IMAGE_TYPES = [:bmp, :gif, :jpeg, :png, :tiff, :psd, :heic, :heif, :webp, :svg, :ico, :cur].freeze
+
   # Returns an array containing the width and height of the image.
   # It will return nil if the image could not be fetched, or if the image type was not recognised.
   #
@@ -178,6 +181,34 @@ class FastImage
     new(uri, options.merge(:type_only=>true)).type
   end
 
+  # Returns a boolean value indicating the image is animated.
+  # It will return nil if the image could not be fetched, or if the image type was not recognised.
+  #
+  # By default there is a timeout of 2 seconds for opening and reading from a remote server.
+  # This can be changed by passing a :timeout => number_of_seconds in the options.
+  #
+  # If you wish FastImage to raise if it cannot find the type of the image for any reason, then pass
+  # :raise_on_failure => true in the options.
+  #
+  # === Example
+  #
+  #   require 'fastimage'
+  #
+  #   FastImage.animated?("test/fixtures/test.gif")
+  #   => false
+  #   FastImage.animated?("test/fixtures/animated.gif")
+  #   => true
+  #
+  # === Supported options
+  # [:timeout]
+  #   Overrides the default timeout of 2 seconds.  Applies both to reading from and opening the http connection.
+  # [:raise_on_failure]
+  #   If set to true causes an exception to be raised if the image type cannot be found for any reason.
+  #
+  def self.animated?(uri, options={})
+    new(uri, options.merge(:animated_only=>true)).animated
+  end
+
   def initialize(uri, options={})
     @uri = uri
     @options = {
@@ -188,7 +219,15 @@ class FastImage
       :http_header      => {}
     }.merge(options)
 
-    @property = @options[:type_only] ? :type : :size
+    @property = if @options[:animated_only]
+      :animated
+    elsif @options[:type_only]
+      :type
+    else
+      :size
+    end
+
+    @type, @state = nil
 
     if uri.respond_to?(:read)
       fetch_using_read(uri)
@@ -211,12 +250,11 @@ class FastImage
     raise SizeNotFound if @options[:raise_on_failure] && @property == :size && !@size
 
   rescue Timeout::Error, SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNRESET,
-    ImageFetchFailure, Net::HTTPBadResponse, EOFError, Errno::ENOENT
-    raise ImageFetchFailure if @options[:raise_on_failure]
-  rescue NoMethodError  # 1.8.7p248 can raise this due to a net/http bug
+    Errno::ENETUNREACH, ImageFetchFailure, Net::HTTPBadResponse, EOFError, Errno::ENOENT,
+    OpenSSL::SSL::SSLError
     raise ImageFetchFailure if @options[:raise_on_failure]
   rescue UnknownImageType
-    raise UnknownImageType if @options[:raise_on_failure]
+    raise if @options[:raise_on_failure]
   rescue CannotParseImage
     if @options[:raise_on_failure]
       if @property == :size
@@ -239,6 +277,17 @@ class FastImage
     fetch_using_http_from_parsed_uri
   end
 
+  # Some invalid locations need escaping
+  def escaped_location(location)
+    begin
+      URI(location)
+    rescue URI::InvalidURIError
+      ::URI::DEFAULT_PARSER.escape(location)
+    else
+      location
+    end
+  end
+
   def fetch_using_http_from_parsed_uri
     http_header = {'Accept-Encoding' => 'identity'}.merge(@options[:http_header])
 
@@ -247,15 +296,10 @@ class FastImage
       if res.is_a?(Net::HTTPRedirection) && @redirect_count < 4
         @redirect_count += 1
         begin
-          newly_parsed_uri = URI.parse(res['Location'])
-          # The new location may be relative - check for that
-          if protocol_relative_url?(res['Location'])
-            @parsed_uri = URI.parse("#{@parsed_uri.scheme}:#{res['Location']}")
-          elsif newly_parsed_uri.scheme != "http" && newly_parsed_uri.scheme != "https"
-            @parsed_uri.path = res['Location']
-          else
-            @parsed_uri = newly_parsed_uri
-          end
+          location = res['Location']
+          raise ImageFetchFailure if location.nil? || location.empty?
+
+          @parsed_uri = URI.join(@parsed_uri, escaped_location(location))
         rescue URI::InvalidURIError
         else
           fetch_using_http_from_parsed_uri
@@ -315,7 +359,7 @@ class FastImage
     proxy = proxy_uri
 
     if proxy
-      @http = Net::HTTP::Proxy(proxy.host, proxy.port).new(@parsed_uri.host, @parsed_uri.port)
+      @http = Net::HTTP::Proxy(proxy.host, proxy.port, proxy.user, proxy.password).new(@parsed_uri.host, @parsed_uri.port)
     else
       @http = Net::HTTP.new(@parsed_uri.host, @parsed_uri.port)
     end
@@ -326,6 +370,7 @@ class FastImage
   end
 
   def fetch_using_read(readable)
+    readable.rewind if readable.respond_to?(:rewind)
     # Pathnames respond to read, but always return the first
     # chunk of the file unlike an IO (even though the
     # docuementation for it refers to IO). Need to supply
@@ -361,7 +406,7 @@ class FastImage
 
     begin
       result = send("parse_#{@property}")
-      if result
+      if result != nil
         # extract exif orientation if it was found
         if @property == :size && result.size == 3
           @orientation = result.pop
@@ -383,9 +428,19 @@ class FastImage
     send("parse_size_for_#{@type}")
   end
 
+  def parse_animated
+    @type = parse_type unless @type
+    @type == :gif ? send("parse_animated_for_#{@type}") : nil
+  end
+
   def fetch_using_base64(uri)
-    data = uri.split(',')[1]
-    fetch_using_read StringIO.new(Base64.decode64(data))
+    decoded = begin
+      Base64.decode64(uri.split(',')[1])
+    rescue
+      raise CannotParseImage
+    end
+    @content_length = decoded.size
+    fetch_using_read StringIO.new(decoded)
   end
 
   module StreamUtil # :nodoc:
@@ -419,19 +474,20 @@ class FastImage
 
     # Peeking beyond the end of the input will raise
     def peek(n)
-      while @strpos + n - 1 >= @str.size
+      while @strpos + n > @str.size
         unused_str = @str[@strpos..-1]
+
         new_string = @read_fiber.resume
+        new_string = @read_fiber.resume if new_string.is_a? Net::ReadAdapter
         raise CannotParseImage if !new_string
-
         # we are dealing with bytes here, so force the encoding
-        new_string.force_encoding("ASCII-8BIT") if String.method_defined? :force_encoding
+        new_string.force_encoding("ASCII-8BIT") if new_string.respond_to? :force_encoding
 
         @str = unused_str + new_string
         @strpos = 0
       end
 
-      result = @str[@strpos..(@strpos + n - 1)]
+      @str[@strpos, n]
     end
 
     def read(n)
@@ -449,7 +505,7 @@ class FastImage
         new_string = @read_fiber.resume
         raise CannotParseImage if !new_string
 
-        new_string.force_encoding("ASCII-8BIT") if String.method_defined? :force_encoding
+        new_string.force_encoding("ASCII-8BIT") if new_string.respond_to? :force_encoding
 
         fetched += new_string.size
         @str = new_string
@@ -475,20 +531,38 @@ class FastImage
     when 0x89.chr + "P"
       :png
     when "II", "MM"
-      :tiff
+      case @stream.peek(11)[8..10]
+      when "APC", "CR\002"
+        nil  # do not recognise CRW or CR2 as tiff
+      else
+        :tiff
+      end
     when '8B'
       :psd
     when "\0\0"
-      # ico has either a 1 (for ico format) or 2 (for cursor) at offset 3
       case @stream.peek(3).bytes.to_a.last
+      when 0
+        # http://www.ftyps.com/what.html
+        # HEIC is composed of nested "boxes". Each box has a header composed of
+        # - Size (32 bit integer)
+        # - Box type (4 chars)
+        # - Extended size: only if size === 1, the type field is followed by 64 bit integer of extended size
+        # - Payload: Type-dependent
+        case @stream.peek(12)[4..-1]
+        when "ftypheic"
+          :heic
+        when "ftypmif1"
+          :heif
+        end
+      # ico has either a 1 (for ico format) or 2 (for cursor) at offset 3
       when 1 then :ico
       when 2 then :cur
       end
     when "RI"
       :webp if @stream.peek(12)[8..11] == "WEBP"
     when "<s"
-      :svg
-    when "<?"
+      :svg if @stream.peek(4) == "<svg"
+    when /\s\s|\s<|<[?!]/, 0xef.chr + 0xbb.chr
       # Peek 10 more chars each time, and if end of file is reached just raise
       # unknown. We assume the <svg tag cannot be within 10 chars of the end of
       # the file, and is within the first 250 chars.
@@ -509,8 +583,222 @@ class FastImage
   end
   alias_method :parse_size_for_cur, :parse_size_for_ico
 
+  class Heic # :nodoc:
+    def initialize(stream)
+      @stream = stream
+    end
+
+    def width_and_height
+      @max_size = nil
+      @primary_box = nil
+      @ipma_boxes = []
+      @ispe_boxes = []
+      @final_size = nil
+
+      catch :finish do
+        read_boxes!
+      end
+
+      @final_size
+    end
+
+    private
+
+    def read_boxes!(max_read_bytes = nil)
+      end_pos = max_read_bytes.nil? ? nil : @stream.pos + max_read_bytes
+      index = 0
+
+      loop do
+        return if end_pos && @stream.pos >= end_pos
+
+        box_type, box_size = read_box_header!
+
+        case box_type
+        when "meta"
+          handle_meta_box(box_size)
+        when "pitm"
+          handle_pitm_box(box_size)
+        when "ipma"
+          handle_ipma_box(box_size)
+        when "hdlr"
+          handle_hdlr_box(box_size)
+        when "iprp", "ipco"
+          read_boxes!(box_size)
+        when "ispe"
+          handle_ispe_box(box_size, index)
+        when "mdat"
+          throw :finish
+        else
+          @stream.read(box_size)
+        end
+
+        index += 1
+      end
+    end
+
+    def handle_ispe_box(box_size, index)
+      throw :finish if box_size < 12
+
+      data = @stream.read(box_size)
+      width, height = data[4...12].unpack("N2")
+      @ispe_boxes << { index: index, size: [width, height] }
+    end
+
+    def handle_hdlr_box(box_size)
+      throw :finish if box_size < 12
+
+      data = @stream.read(box_size)
+      throw :finish if data[8...12] != "pict"
+    end
+
+    def handle_ipma_box(box_size)
+      @stream.read(3)
+      flags3 = read_uint8!
+      entries_count = read_uint32!
+
+      entries_count.times do
+        id = read_uint16!
+        essen_count = read_uint8!
+
+        essen_count.times do
+          property_index = read_uint8! & 0x7F
+
+          if flags3 & 1 == 1
+            property_index = (property_index << 7) + read_uint8!
+          end
+
+          @ipma_boxes << { id: id, property_index: property_index - 1 }
+        end
+      end
+    end
+
+    def handle_pitm_box(box_size)
+      data = @stream.read(box_size)
+      @primary_box = data[4...6].unpack("S>")[0]
+    end
+
+    def handle_meta_box(box_size)
+      throw :finish if box_size < 4
+
+      @stream.read(4)
+      read_boxes!(box_size - 4)
+
+      throw :finish if !@primary_box
+
+      primary_indices = @ipma_boxes
+                        .select { |box| box[:id] == @primary_box }
+                        .map { |box| box[:property_index] }
+
+      ispe_box = @ispe_boxes.find do |box|
+        primary_indices.include?(box[:index])
+      end
+
+      if ispe_box
+        @final_size = ispe_box[:size]
+      end
+
+      throw :finish
+    end
+
+    def read_box_header!
+      size = read_uint32!
+      type = @stream.read(4)
+      [type, size - 8]
+    end
+
+    def read_uint8!
+      @stream.read(1).unpack("C")[0]
+    end
+
+    def read_uint16!
+      @stream.read(2).unpack("S>")[0]
+    end
+
+    def read_uint32!
+      @stream.read(4).unpack("N")[0]
+    end
+  end
+
+  def parse_size_for_heic
+    heic = Heic.new(@stream)
+    heic.width_and_height
+  end
+
+  def parse_size_for_heif
+    heic = Heic.new(@stream)
+    heic.width_and_height
+  end
+
+  class Gif # :nodoc:
+    def initialize(stream)
+      @stream = stream
+    end
+
+    def width_and_height
+      @stream.read(11)[6..10].unpack('SS')
+    end
+
+    # Checks if a delay between frames exists and if it does, then the GIFs is
+    # animated
+    def animated?
+      frames = 0
+
+      # "GIF" + version (3) + width (2) + height (2)
+      @stream.skip(10)
+
+      # fields (1) + bg color (1) + pixel ratio (1)
+      fields = @stream.read(3).unpack("CCC")[0]
+      if fields & 0x80 != 0 # Global Color Table
+        # 2 * (depth + 1) colors, each occupying 3 bytes (RGB)
+        @stream.skip(3 * 2 ** ((fields & 0x7) + 1))
+      end
+
+      loop do
+        block_type = @stream.read(1).unpack("C")[0]
+
+        if block_type == 0x21 # Graphic Control Extension
+          # extension type (1) + size (1)
+          size = @stream.read(2).unpack("CC")[1]
+          @stream.skip(size)
+          skip_sub_blocks
+        elsif block_type == 0x2C # Image Descriptor
+          frames += 1
+          return true if frames > 1
+
+          # left position (2) + top position (2) + width (2) + height (2) + fields (1)
+          fields = @stream.read(9).unpack("SSSSC")[4]
+          if fields & 0x80 != 0 # Local Color Table
+            # 2 * (depth + 1) colors, each occupying 3 bytes (RGB)
+            @stream.skip(3 * 2 ** ((fields & 0x7) + 1))
+          end
+
+          @stream.skip(1) # LZW min code size (1)
+          skip_sub_blocks
+        else
+          break # unrecognized block
+        end
+      end
+
+      false
+    end
+
+    private
+
+    def skip_sub_blocks
+      loop do
+        size = @stream.read(1).unpack("C")[0]
+        if size == 0
+          break
+        else
+          @stream.skip(size)
+        end
+      end
+    end
+  end
+
   def parse_size_for_gif
-    @stream.read(11)[6..10].unpack('SS')
+    gif = Gif.new(@stream)
+    gif.width_and_height
   end
 
   def parse_size_for_png
@@ -518,6 +806,7 @@ class FastImage
   end
 
   def parse_size_for_jpeg
+    exif = nil
     loop do
       @state = case @state
       when nil
@@ -533,7 +822,8 @@ class FastImage
           io = StringIO.new(data)
           if io.read(4) == "Exif"
             io.read(2)
-            @exif = Exif.new(IOStream.new(io)) rescue nil
+            new_exif = Exif.new(IOStream.new(io)) rescue nil
+            exif ||= new_exif # only use the first APP1 segment
           end
           :started
         when 0xe0..0xef
@@ -553,8 +843,8 @@ class FastImage
         @stream.skip(3)
         height = @stream.read_int
         width = @stream.read_int
-        width, height = height, width if @exif && @exif.rotated?
-        return [width, height, @exif ? @exif.orientation : 1]
+        width, height = height, width if exif && exif.rotated?
+        return [width, height, exif ? exif.orientation : 1]
       end
     end
   end
@@ -563,10 +853,10 @@ class FastImage
     d = @stream.read(32)[14..28]
     header = d.unpack("C")[0]
 
-    result = if header == 40
-               d[4..-1].unpack('l<l<')
-             else
+    result = if header == 12
                d[4..8].unpack('SS')
+             else
+               d[4..-1].unpack('l<l<')
              end
 
     # ImageHeight is expressed in pixels. The absolute value is necessary because ImageHeight can be negative
@@ -575,7 +865,7 @@ class FastImage
 
   def parse_size_for_webp
     vp8 = @stream.read(16)[12..15]
-    len = @stream.read(4).unpack("V")
+    _len = @stream.read(4).unpack("V")
     case vp8
     when "VP8 "
       parse_size_vp8
@@ -617,6 +907,7 @@ class FastImage
 
     def initialize(stream)
       @stream = stream
+      @width, @height, @orientation = nil
       parse_exif
     end
 
@@ -696,6 +987,7 @@ class FastImage
   class Svg # :nodoc:
     def initialize(stream)
       @stream = stream
+      @width, @height, @ratio, @viewbox_width, @viewbox_height = nil
       parse_svg
     end
 
@@ -732,7 +1024,7 @@ class FastImage
             return if @width
           elsif attr_name.join =~ /viewbox/i
             values = attr_value.split(/\s/)
-            if values[2].to_f > 0 && values[3].to_f > 0 
+            if values[2].to_f > 0 && values[3].to_f > 0
               @ratio = values[2].to_f / values[3].to_f
               @viewbox_width = values[2].to_i
               @viewbox_height = values[3].to_i
@@ -766,4 +1058,9 @@ class FastImage
     svg = Svg.new(@stream)
     svg.width_and_height
   end
+
+  def parse_animated_for_gif
+    gif = Gif.new(@stream)
+    gif.animated?
+  end
 end

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: fastimage
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.4
 platform: ruby
 authors:
 - Stephen Sykes
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-02-23 00:00:00.000000000 Z
+date: 2021-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: fakeweb
+  name: fakeweb-fi
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.5'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: FastImage finds the size or type of an image given its uri by fetching
@@ -81,25 +81,24 @@ homepage: http://github.com/sdsykes/fastimage
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
-- --charset=UTF-8
+- "--charset=UTF-8"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.0.14.1
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: FastImage - Image info fast
 test_files: []