fastimage 1.8.1 → 2.2.3

metadata

@@ -1,37 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: fastimage
 version: !ruby/object:Gem::Version
-  version: 1.8.1
+  version: 2.2.3
 platform: ruby
 authors:
 - Stephen Sykes
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-12-02 00:00:00.000000000 Z
+date: 2021-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: addressable
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.3'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.3.5
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.3'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.3.5
-- !ruby/object:Gem::Dependency
-  name: fakeweb
+  name: fakeweb-fi
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -50,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.5'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -97,39 +77,11 @@ files:
 - MIT-LICENSE
 - README.textile
 - lib/fastimage.rb
-- lib/fastimage/fbr.rb
-- test/fixtures/bad.jpg
-- test/fixtures/exif_orientation.jpg
-- test/fixtures/faulty.jpg
-- test/fixtures/folder with spaces/test.bmp
-- test/fixtures/gzipped.jpg
-- test/fixtures/infinite.jpg
-- test/fixtures/man.ico
-- test/fixtures/orient_2.jpg
-- test/fixtures/test.bmp
-- test/fixtures/test.cur
-- test/fixtures/test.gif
-- test/fixtures/test.jpg
-- test/fixtures/test.png
-- test/fixtures/test.psd
-- test/fixtures/test.svg
-- test/fixtures/test.tiff
-- test/fixtures/test2.bmp
-- test/fixtures/test2.jpg
-- test/fixtures/test2.tiff
-- test/fixtures/test3.jpg
-- test/fixtures/test4.jpg
-- test/fixtures/test_partial_viewport.svg
-- test/fixtures/truncated_gzipped.jpg
-- test/fixtures/webp_vp8.webp
-- test/fixtures/webp_vp8l.webp
-- test/fixtures/webp_vp8x.webp
-- test/test.rb
 homepage: http://github.com/sdsykes/fastimage
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--charset=UTF-8"
 require_paths:
@@ -138,17 +90,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: FastImage - Image info fast
-test_files:
-- test/test.rb
+test_files: []

data/lib/fastimage/fbr.rb

@@ -1,66 +0,0 @@
-# Poor Man's Fiber (API compatible Thread based Fiber implementation for Ruby 1.8)
-# (c) 2008 Aman Gupta (tmm1)
-
-unless defined? Fiber
-  require 'thread'
-
-  class FiberError < StandardError; # :nodoc:
-  end
-
-  class Fiber # :nodoc:
-    def initialize
-      raise ArgumentError, 'new Fiber requires a block' unless block_given?
-
-      @yield = Queue.new
-      @resume = Queue.new
-
-      @thread = Thread.new{ @yield.push [yield(*@resume.pop)] }
-      @thread.abort_on_exception = true
-      @thread[:fiber] = self
-    end
-    attr_reader :thread
-
-    def resume *args
-      raise FiberError, 'dead fiber called' unless @thread.alive?
-      @resume.push(args)
-      result = @yield.pop
-      result.size > 1 ? result : result.first
-    end
-
-    def yield *args
-      @yield.push(args)
-      result = @resume.pop
-      result.size > 1 ? result : result.first
-    end
-
-    def self.yield *args
-      if fiber = Thread.current[:fiber]
-        fiber.yield(*args)
-      else
-        raise FiberError, 'not inside a fiber'
-      end
-    end
-
-    def self.current
-      if Thread.current == Thread.main
-        return Thread.main[:fiber] ||= RootFiber.new
-      end
-
-      Thread.current[:fiber] or raise FiberError, 'not inside a fiber'
-    end
-
-    def inspect
-      "#<#{self.class}:0x#{self.object_id.to_s(16)}>"
-    end
-  end
-
-  class RootFiber < Fiber # :nodoc:
-    def initialize
-      # XXX: what is a root fiber anyway?
-    end
-
-    def self.yield *args
-      raise FiberError, "can't yield from root fiber"
-    end
-  end
-end

data/test/fixtures/test.svg

@@ -1,43 +0,0 @@
-<?xml version="1.0"?>
-
-<svg version="1.1" 
-     xmlns="http://www.w3.org/2000/svg"
-     xmlns:xlink="http://www.w3.org/1999/xlink"
-     width="200" height="300"
-     style="background-color: #D2B48C;"
-     onload="loaded()">
-  <script type="text/javascript"><![CDATA[
-      function loaded() {
-        // change onloadFunc to point to your real onload function that you
-        // want called when the page is truly ready
-        var onloadFunc = doload;
-        
-        if (top.svgweb) {
-          top.svgweb.addOnLoad(onloadFunc, true, window);
-        } else {
-          onloadFunc();
-        }
-      }   
-      
-     function doload() {
-        // developers original onload handler
-        
-        // add an event listener to our circle; on* style events added right
-        // to the markup are not yet supported
-        var circle = document.getElementById('myCircle');
-        circle.addEventListener('mousedown', function(evt) {
-          alert('You pressed the mouse button on our circle: ' + evt.target.id);
-        }, false);
-     }
-  ]]></script>
-  <g id="myGroup" 
-     fill="blue" 
-     style="font-size: 18px; text-anchor: middle; font-family: serif;">
-    <circle id="myCircle"
-            cx="100" cy="75" r="50"
-            stroke="firebrick"
-            stroke-width="3" />
-    <text x="100" y="155">Hello World</text>
-    <text x="100" y="175">From An SVG File!</text>
-  </g>
-</svg>

data/test/fixtures/test_partial_viewport.svg

@@ -1,9 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" version="1.0" width="860" viewBox="0 0 215 100">
-<path d="M4.8 72.6C8.4 77.2 40.3 78.8 48 73.8 64.9 77.7 98.6 75.9 97.7 69.2 97 63.2 -16.4 46.1 4.8 72.6zM114.8 69.3C130.6 78.8 162 75.7 167.9 73.8 173.6 80.6 209.4 79.6 211.3 74.3 213.2 68.8 90.7 18.1 114.8 69.3z" style="fill:#cfcfcf"/>
-<path d="M67.9 31.1C42.1 30.4 27.6 58.1 34.8 66.4 44.4 77.6 89.3 73.7 95.7 67.1 105.3 57.4 93.5 31.7 67.9 31.1z" style="fill:#cca776;stroke:#715835"/>
-<path d="M25.7 43.9C2.8 43.8 -0.2 64.2 4.5 71.6 7.4 76.3 42.2 76.8 47.1 70.9 52.5 64.4 49 44 25.7 43.9z" style="fill:#ffe2af;stroke:#daa240"/>
-<path d="M141.8 33.1C108.7 32.1 105.2 59.2 112.9 67.3 121.1 76 163.9 75.9 170.9 67.9 177.5 60.2 175.1 34.2 141.8 33.1z" style="fill:#a7dcc1;stroke:#5ba67e"/>
-<path d="M188.8 43.6C166.1 43.1 160 64.7 165.9 71.8 171.6 78.6 203.4 78 209.3 72.3 215.6 66.1 211 44.1 188.8 43.6z" style="fill:#ffd1ba;stroke:#cc7f58"/>
-<path d="M141.6 2.5C118.4 2 105.7 25 115 34.5 120.9 40.5 160.2 41.3 166.4 34.3 174.1 25.6 164.6 3 141.6 2.5z" style="fill:#fbf499;stroke:#cbc238"/>
-<path d="M31.3 54.6C32.6 56.7 32.6 58.1 33 60.9M37.4 60.2C37.5 57.4 37 56.4 36 54.5M84.1 56.3C83.8 53.4 83.3 50.4 81.7 47.5M90.5 56.3C90.3 53.3 89.9 50.2 88.4 47.2M121.5 53C121.1 50.2 121.7 47.3 123 44.4M127.3 53.5C126.8 50.7 127.7 47.8 129.3 44.9M125.1 15.9C125.1 13.3 125.9 11.4 126.9 8.8M132.8 8.6C131.9 11 131 13.5 131.1 15.9M174.8 53.3C173.5 55.9 172.5 58.6 172.6 61.6M181.4 53.5C180 55.4 178.6 60.4 179.7 62.1" style="fill:none;stroke:#000000;stroke-width:1.25;stroke-linecap:round"/>
-</svg>

data/test/test.rb

@@ -1,323 +0,0 @@
-require 'rubygems'
-
-require 'test/unit'
-
-PathHere = File.dirname(__FILE__)
-$LOAD_PATH.unshift File.join(PathHere, "..", "lib")
-
-require 'fastimage'
-require 'fakeweb'
-
-FixturePath = File.join(PathHere, "fixtures")
-
-GoodFixtures = {
-  "test.bmp"=>[:bmp, [40, 27]],
-  "test2.bmp"=>[:bmp, [1920, 1080]],
-  "test.gif"=>[:gif, [17, 32]],
-  "test.jpg"=>[:jpeg, [882, 470]],
-  "test.png"=>[:png, [30, 20]],
-  "test2.jpg"=>[:jpeg, [250, 188]],
-  "test3.jpg"=>[:jpeg, [630, 367]],
-  "test4.jpg"=>[:jpeg, [1485, 1299]],
-  "test.tiff"=>[:tiff, [85, 67]],
-  "test2.tiff"=>[:tiff, [333, 225]],
-  "test.psd"=>[:psd, [17, 32]],
-  "exif_orientation.jpg"=>[:jpeg, [600, 450]],
-  "infinite.jpg"=>[:jpeg, [160,240]],
-  "orient_2.jpg"=>[:jpeg, [230,408]],
-  "favicon.ico" => [:ico, [16, 16]],
-  "man.ico" => [:ico, [48, 48]],
-  "test.cur" => [:cur, [32, 32]],
-  "webp_vp8x.webp" => [:webp, [386, 395]],
-  "webp_vp8l.webp" => [:webp, [386, 395]],
-  "webp_vp8.webp" => [:webp, [550, 368]],
-  "test.svg" => [:svg, [200, 300]],
-  "test_partial_viewport.svg" => [:svg, [860, 400]]
-}
-
-BadFixtures = [
-  "faulty.jpg",
-  "test_rgb.ct",
-  "test.xml"
-]
-# man.ico courtesy of http://www.iconseeker.com/search-icon/artists-valley-sample/business-man-blue.html
-# test_rgb.ct courtesy of http://fileformats.archiveteam.org/wiki/Scitex_CT
-# test.cur courtesy of http://mimidestino.deviantart.com/art/Clash-Of-Clans-Dragon-Cursor-s-Punteros-489070897
-
-TestUrl = "http://example.nowhere/"
-
-# this image fetch allows me to really test that fastimage is truly fast
-# but it's not ideal relying on external resources and connectivity speed
-LargeImage = "http://upload.wikimedia.org/wikipedia/commons/b/b4/Mardin_1350660_1350692_33_images.jpg"
-LargeImageInfo = [:jpeg, [9545, 6623]]
-LargeImageFetchLimit = 2  # seconds
-
-HTTPSImage = "https://upload.wikimedia.org/wikipedia/commons/b/b4/Mardin_1350660_1350692_33_images.jpg"
-HTTPSImageInfo = [:jpeg, [9545, 6623]]
-
-GoodFixtures.each do |fn, info|
-  FakeWeb.register_uri(:get, "#{TestUrl}#{fn}", :body => File.join(FixturePath, fn))
-end
-BadFixtures.each do |fn|
-  FakeWeb.register_uri(:get, "#{TestUrl}#{fn}", :body => File.join(FixturePath, fn))
-end
-
-GzipTestImg = "gzipped.jpg"
-FakeWeb.register_uri(:get, "#{TestUrl}#{GzipTestImg}", :body => File.join(FixturePath, GzipTestImg), :content_encoding => "gzip")
-GzipTestImgTruncated = "truncated_gzipped.jpg"
-FakeWeb.register_uri(:get, "#{TestUrl}#{GzipTestImgTruncated}", :body => File.join(FixturePath, GzipTestImgTruncated), :content_encoding => "gzip")
-GzipTestImgSize = [970, 450]
-
-class FastImageTest < Test::Unit::TestCase
-  def test_should_report_type_correctly
-    GoodFixtures.each do |fn, info|
-      assert_equal info[0], FastImage.type(TestUrl + fn)
-      assert_equal info[0], FastImage.type(TestUrl + fn, :raise_on_failure=>true)
-    end
-  end
-
-  def test_should_report_size_correctly
-    GoodFixtures.each do |fn, info|
-      assert_equal info[1], FastImage.size(TestUrl + fn)
-      assert_equal info[1], FastImage.size(TestUrl + fn, :raise_on_failure=>true)
-    end
-  end
-
-  def test_should_return_nil_on_fetch_failure
-    assert_nil FastImage.size(TestUrl + "does_not_exist")
-  end
-
-  def test_should_return_nil_for_faulty_jpeg_where_size_cannot_be_found
-    assert_nil FastImage.size(TestUrl + "faulty.jpg")
-  end
-
-  def test_should_return_nil_when_image_type_not_known
-    assert_nil FastImage.size(TestUrl + "test_rgb.ct")
-  end
-
-  def test_should_return_nil_if_timeout_occurs
-    assert_nil FastImage.size("http://example.com/does_not_exist", :timeout=>0.001)
-  end
-
-  def test_should_raise_when_asked_to_when_size_cannot_be_found
-    assert_raises(FastImage::SizeNotFound) do
-      FastImage.size(TestUrl + "faulty.jpg", :raise_on_failure=>true)
-    end
-  end
-
-  def test_should_raise_when_asked_to_when_timeout_occurs
-    assert_raises(FastImage::ImageFetchFailure) do
-      FastImage.size("http://example.com/does_not_exist", :timeout=>0.001, :raise_on_failure=>true)
-    end
-  end
-
-  def test_should_raise_when_asked_to_when_file_does_not_exist
-    assert_raises(FastImage::ImageFetchFailure) do
-      FastImage.size("http://www.google.com/does_not_exist_at_all", :raise_on_failure=>true)
-    end
-  end
-
-  def test_should_raise_when_asked_when_image_type_not_known
-    assert_raises(FastImage::UnknownImageType) do
-      FastImage.size(TestUrl + "test_rgb.ct", :raise_on_failure=>true)
-    end
-  end
-
-  def test_should_raise_unknown_image_typ_when_file_is_non_svg_xml
-    assert_raises(FastImage::UnknownImageType) do
-      FastImage.size(TestUrl + "test.xml", :raise_on_failure=>true)
-    end
-  end
-
-  def test_should_report_type_correctly_for_local_files
-    GoodFixtures.each do |fn, info|
-      assert_equal info[0], FastImage.type(File.join(FixturePath, fn))
-    end
-  end
-
-  def test_should_report_size_correctly_for_local_files
-    GoodFixtures.each do |fn, info|
-      assert_equal info[1], FastImage.size(File.join(FixturePath, fn))
-    end
-  end
-
-  def test_should_report_type_correctly_for_ios
-    GoodFixtures.each do |fn, info|
-      File.open(File.join(FixturePath, fn), "r") do |io|
-        assert_equal info[0], FastImage.type(io)
-      end
-    end
-  end
-
-  def test_should_report_size_correctly_for_ios
-    GoodFixtures.each do |fn, info|
-      File.open(File.join(FixturePath, fn), "r") do |io|
-        assert_equal info[1], FastImage.size(io)
-      end
-    end
-  end
-
-  def test_should_report_size_correctly_on_io_object_twice
-    GoodFixtures.each do |fn, info|
-      File.open(File.join(FixturePath, fn), "r") do |io|
-        assert_equal info[1], FastImage.size(io)
-        assert_equal info[1], FastImage.size(io)
-      end
-    end
-  end
-
-  def test_should_report_size_correctly_for_local_files_with_path_that_has_spaces
-    Dir.chdir(PathHere) do
-      assert_equal GoodFixtures["test.bmp"][1], FastImage.size(File.join("fixtures", "folder with spaces", "test.bmp"))
-    end
-  end
-
-  def test_should_return_nil_on_fetch_failure_for_local_path
-    assert_nil FastImage.size("does_not_exist")
-  end
-
-  def test_should_return_nil_for_faulty_jpeg_where_size_cannot_be_found_for_local_file
-    assert_nil FastImage.size(File.join(FixturePath, "faulty.jpg"))
-  end
-
-  def test_should_return_nil_when_image_type_not_known_for_local_file
-    assert_nil FastImage.size(File.join(FixturePath, "test_rgb.ct"))
-  end
-
-  def test_should_raise_when_asked_to_when_size_cannot_be_found_for_local_file
-    assert_raises(FastImage::SizeNotFound) do
-      FastImage.size(File.join(FixturePath, "faulty.jpg"), :raise_on_failure=>true)
-    end
-  end
-
-  def test_should_handle_permanent_redirect
-    url = "http://example.com/foo.jpeg"
-    register_redirect(url, TestUrl + GoodFixtures.keys.first)
-    assert_equal GoodFixtures[GoodFixtures.keys.first][1], FastImage.size(url, :raise_on_failure=>true)
-  end
-
-  def test_should_handle_permanent_redirect_4_times
-    first_url = "http://example.com/foo.jpeg"
-    register_redirect(first_url, "http://example.com/foo2.jpeg")
-    register_redirect("http://example.com/foo2.jpeg", "http://example.com/foo3.jpeg")
-    register_redirect("http://example.com/foo3.jpeg", "http://example.com/foo4.jpeg")
-    register_redirect("http://example.com/foo4.jpeg", TestUrl + GoodFixtures.keys.first)
-    assert_equal GoodFixtures[GoodFixtures.keys.first][1], FastImage.size(first_url, :raise_on_failure=>true)
-  end
-
-  def test_should_raise_on_permanent_redirect_5_times
-    first_url = "http://example.com/foo.jpeg"
-    register_redirect(first_url, "http://example.com/foo2.jpeg")
-    register_redirect("http://example.com/foo2.jpeg", "http://example.com/foo3.jpeg")
-    register_redirect("http://example.com/foo3.jpeg", "http://example.com/foo4.jpeg")
-    register_redirect("http://example.com/foo4.jpeg", "http://example.com/foo5.jpeg")
-    register_redirect("http://example.com/foo5.jpeg", TestUrl + GoodFixtures.keys.first)
-    assert_raises(FastImage::ImageFetchFailure) do
-      FastImage.size(first_url, :raise_on_failure=>true)
-    end
-  end
-
-  def test_should_handle_permanent_redirect_with_relative_url
-    url = "http://example.nowhere/foo.jpeg"
-    register_redirect(url, "/" + GoodFixtures.keys.first)
-    assert_equal GoodFixtures[GoodFixtures.keys.first][1], FastImage.size(url, :raise_on_failure=>true)
-  end
-
-  def register_redirect(from, to)
-    resp = Net::HTTPMovedPermanently.new(1.0, 302, "Moved")
-    resp['Location'] = to
-    FakeWeb.register_uri(:get, from, :response=>resp)
-  end
-
-  def test_should_fetch_info_of_large_image_faster_than_downloading_the_whole_thing
-    time = Time.now
-    size = FastImage.size(LargeImage)
-    size_time = Time.now
-    assert size_time - time < LargeImageFetchLimit
-    assert_equal LargeImageInfo[1], size
-    time = Time.now
-    type = FastImage.type(LargeImage)
-    type_time = Time.now
-    assert type_time - time < LargeImageFetchLimit
-    assert_equal LargeImageInfo[0], type
-  end
-
-  # This test doesn't actually test the proxy function, but at least
-  # it excercises the code. You could put anything in the http_proxy and it would still pass.
-  # Any ideas on how to actually test this?
-  def test_should_fetch_via_proxy
-    file = "test.gif"
-    actual_size = GoodFixtures[file][1]
-    ENV['http_proxy'] = "http://my.proxy.host:8080"
-    size = FastImage.size(TestUrl + file)
-    ENV['http_proxy'] = nil
-    assert_equal actual_size, size
-  end
-
-  def test_should_fetch_via_proxy_option
-    file = "test.gif"
-    actual_size = GoodFixtures[file][1]
-    size = FastImage.size(TestUrl + file, :proxy => "http://my.proxy.host:8080")
-    assert_equal actual_size, size
-  end
-
-  def test_should_handle_https_image
-    size = FastImage.size(HTTPSImage)
-    assert_equal HTTPSImageInfo[1], size
-  end
-
-  require 'pathname'
-  def test_should_handle_pathname
-    # bad.jpg does not have the size info in the first 256 bytes
-    # so this tests if we are able to read past that using a
-    # Pathname (which has a different API from an IO).
-    path = Pathname.new(File.join(FixturePath, "bad.jpg"))
-    assert_equal([500,500], FastImage.size(path))
-  end
-
-  def test_should_report_type_and_size_correctly_for_stringios
-    GoodFixtures.each do |fn, info|
-      string = File.read(File.join(FixturePath, fn))
-      stringio = StringIO.new(string)
-      assert_equal info[0], FastImage.type(stringio)
-      assert_equal info[1], FastImage.size(stringio)
-    end
-  end
-
-  def test_gzipped_file
-    url = "http://example.nowhere/#{GzipTestImg}"
-    assert_equal([970, 450], FastImage.size(url))
-  end
-
-  def test_truncated_gzipped_file
-    url = "http://example.nowhere/#{GzipTestImgTruncated}"
-    assert_raises(FastImage::SizeNotFound) do
-      FastImage.size(url, :raise_on_failure => true)
-    end
-  end
-
-  def test_cant_access_shell
-    url = "|echo>shell_test"
-    %x{rm -f shell_test}
-    FastImage.size(url)
-    assert_raises(Errno::ENOENT) do
-      File.open("shell_test")
-    end
-  ensure
-    %x{rm -f shell_test}
-  end
-
-  def test_content_length
-    url = "#{TestUrl}with_content_length.gif"
-    FakeWeb.register_uri(:get, url, :body => File.join(FixturePath, "test.jpg"), :content_length => 52)
-
-    assert_equal 52, FastImage.new(url).content_length
-  end
-
-  def test_content_length_not_provided
-    url = "#{TestUrl}without_content_length.gif"
-    FakeWeb.register_uri(:get, url, :body => File.join(FixturePath, "test.jpg"))
-
-    assert_equal nil, FastImage.new(url).content_length
-  end
-end