micky 0.7.1 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2be6c8fcc885dfca7a1733f5957e089906e033347e39f37a570804692a1430b
-  data.tar.gz: 043bdc08aa5c099bf07927ba30011f87696ec8302eb7de9257865f857a5f1a57
+  metadata.gz: ecea094f30e0551b84949260cd3c78b34673cb69bcefdcd746b506938adffeab
+  data.tar.gz: 98874aec481b78fdb48fe0ae50248ec51683e299b3a6c6770706a706b6266894
 SHA512:
-  metadata.gz: 585dcfdc3f897d0880acab1591331774db0f18b189adb1e2111371e4d5b8075bb9f0975e58b3c1b9007c7d2d6f49ce0b95663b944adcff2e9b74a7aeb257b367
-  data.tar.gz: 91645ed087cb98abd4c16bae8eac88d088e62cf8fca49cddd1f05c526a9ce560de122d506f6a314003d665a5df269d6ed735c23eccaa7b08acf3466de5addca8
+  metadata.gz: 6a0f768ceb90965a4203f30c1d68de2a82f328f3fa5cbf18a68ebe94f54c0018cd2df1c2ef5399af64bae8221868368407bd98d60cbdf78beb59c31ee80a7ae7
+  data.tar.gz: a277768598966377bd039e5a4df2340ac679d10728d9b913b45f3882159b1812d8eccf768424a43b6f4b4244a9b2e57c400a09b4dc685d2ab1eda56040a66f0f

data/.github/workflows/ci.yml

@@ -0,0 +1,20 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['3.3', '3.4', '4.0']
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle exec rake test

data/README.md

@@ -76,6 +76,46 @@ Micky.get('http://drpm.me/unwz.jpg', headers: { 'Accept' => 'text/html' })
 Micky.get('http://urls.api.twitter.com/1/urls/count.json', query: { url: 'dropmeme.com' })
 ```
 
+### Limiting what an untrusted server can cost you
+
+By default Micky reads a response to its end, and `:timeout` bounds each socket
+operation rather than the call as a whole. Against a server you don’t control,
+neither is a limit: a body can be as large as the server cares to send, and a
+server that answers slowly but never stalls is never timed out at all.
+
+`:max_response_size` is the number of body bytes Micky will read. Past that it
+stops reading and drops the connection, so an oversized response costs you the
+limit and not the body. The call returns `nil`, or raises
+`Micky::TooLargeResponse` when `:raise_errors` is set:
+
+```ruby
+Micky.get(url, max_response_size: 512 * 1024) # nil if the body is larger
+```
+
+Pass `:truncate` to get the first `:max_response_size` bytes instead. A
+truncated response is useful for some formats and useless for others, so this
+is opt-in: fine for HTML, not for an image.
+
+```ruby
+response = Micky.get(url, max_response_size: 512 * 1024, truncate: true)
+response.body.bytesize # at most 524288
+response.truncated?    # true if the server had more to send
+```
+
+`:total_timeout` is a wall clock for the whole call, redirects included. It is
+the only option that bounds a server which drips one byte at a time, or a long
+chain of individually-reasonable redirects:
+
+```ruby
+Micky.get(url, timeout: 5, total_timeout: 10)
+```
+
+On expiry Micky returns `nil`, or raises `Micky::TotalTimeout` when
+`:raise_errors` is set. It defaults to 20 seconds; pass `nil` for no limit.
+
+`:max_response_size` has no default, since downloading a large file can be the
+point. For most callers it is the only option worth setting explicitly.
+
 ### OAuth `Authorization` header
 
 Micky supports creating a OAuth `Authorization` header with the help of the
@@ -162,7 +202,6 @@ end
 ## TODO
 
 - Support :basic_auth and :digest_auth through [HTTPauth](https://github.com/Manfred/HTTPauth)
-- Add tests
 - Better document configuration options in README
 
 ## Contributing

data/Rakefile

@@ -1 +1,9 @@
 require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/*_test.rb'
+end
+
+task default: :test

data/lib/micky/errors.rb

@@ -30,6 +30,10 @@ module Micky
   end
   class TooManyRedirects < ServerError
   end
+  class TotalTimeout < ServerError
+  end
+  class TooLargeResponse < ServerError
+  end
   class NoRedirectLocation < ServerError
   end
   class InvalidLocation < ServerError

data/lib/micky/request.rb

@@ -9,20 +9,40 @@ module Micky
         value = opts.has_key?(name) ? opts[name] : Micky.public_send(name)
         instance_variable_set "@#{name}", value
       end
+
+      @truncated = false
     end
 
     def get(uri)
       @request_class_name = 'Get'
-      request_with_redirect_handling(uri)
+      with_total_timeout { request_with_redirect_handling(uri) }
     end
 
     def head(uri)
       @request_class_name = 'Head'
-      request_with_redirect_handling(uri)
+      with_total_timeout { request_with_redirect_handling(uri) }
     end
 
   private
 
+    # `timeout` bounds each socket operation, not the whole call. A slow drip or a
+    # long redirect chain never trips it. `total_timeout` is a wall clock for the
+    # whole call, redirects included.
+    # We pass our own exception class: Timeout only converts the instance it raised
+    # itself, so an enclosing block’s expiry passes through untouched and ours is
+    # never caught by a `rescue Timeout::Error` in between.
+    def with_total_timeout
+      return yield unless @total_timeout
+
+      begin
+        Timeout.timeout(@total_timeout, Micky::TotalTimeout) { yield }
+      rescue Micky::TotalTimeout => e
+        raise e if @raise_errors
+        log "Total timeout reached (#{@total_timeout}s)"
+        nil
+      end
+    end
+
     def request_with_redirect_handling(uri, redirect_count = 0)
       if redirect_count >= @max_redirects
         raise Micky::TooManyRedirects, "Max redirects reached (#{@max_redirects})" if @raise_errors
@@ -32,8 +52,15 @@ module Micky
 
       case response = request(uri)
       when Net::HTTPSuccess
+        if @truncated && !@truncate
+          raise Micky::TooLargeResponse, "Response larger than #{@max_response_size} bytes" if @raise_errors
+          log "Response larger than #{@max_response_size} bytes"
+          return nil
+        end
+
         debug "#{response.code} success"
-        Response.new(response, @uri)
+        log "Response truncated at #{@max_response_size} bytes" if @truncated
+        Response.new(response, @uri, truncated: @truncated)
       when Net::HTTPRedirection
         previous_uri = uri
         uri = response['Location']
@@ -48,15 +75,19 @@ module Micky
           if uri.start_with? '//'
             # Protocol-relative
             uri = Micky::URI(uri).to_s
-          elsif uri.start_with? '/'
-            # Host-relative
-            previous_uri = Micky::URI(previous_uri)
-            uri = File.join("#{previous_uri.scheme}://#{previous_uri.host}", uri)
           else
-            # Path-relative
             previous_uri = Micky::URI(previous_uri)
-            previous_directory = previous_uri.path.sub(/[^\/]+\z/, '')
-            uri = File.join("#{previous_uri.scheme}://#{previous_uri.host}#{previous_directory}", uri)
+            origin = "#{previous_uri.scheme}://#{previous_uri.host}"
+            origin += ":#{previous_uri.port}" unless previous_uri.port == previous_uri.default_port
+
+            if uri.start_with? '/'
+              # Host-relative
+              uri = File.join(origin, uri)
+            else
+              # Path-relative
+              previous_directory = previous_uri.path.sub(/[^\/]+\z/, '')
+              uri = File.join("#{origin}#{previous_directory}", uri)
+            end
           end
         end
 
@@ -156,7 +187,11 @@ module Micky
       @headers.each { |k,v| request[k] = v }
 
       begin
-        http.request(request)
+        if @max_response_size
+          http.request(request) { |response| read_capped_body(response) }
+        else
+          http.request(request)
+        end
       rescue Zlib::Error
         request['Accept-Encoding'] = 'identity'
         retry
@@ -171,6 +206,36 @@ module Micky
       end
     end
 
+    # Without a block, Net::HTTP reads the whole body into memory before we see any
+    # of it. Reading it ourselves lets us stop at `max_response_size` and drop the
+    # connection. Runs on redirect hops too, since a redirect can carry a body.
+    def read_capped_body(response)
+      # Net::HTTP yields nothing for a body-less response (204, HEAD) and for an
+      # empty one alike, so decide up front whether the body is nil or empty
+      body = +''.b if response.class.body_permitted? && @request_class_name == 'Get'
+      @truncated = false
+
+      response.read_body do |chunk|
+        room = @max_response_size - body.bytesize
+
+        if chunk.bytesize > room
+          body << chunk.byteslice(0, room)
+          @truncated = true
+          break
+        end
+
+        body << chunk
+      end
+
+      # `read_body` only sets `@read` at the end of the body, and `break` skips that.
+      # Without it, `response.body` would resume reading where we stopped.
+      response.instance_variable_set(:@read, true)
+      response.body = body
+
+      # The server’s Content-Length no longer matches the body
+      response['content-length'] = body.bytesize.to_s if @truncated
+    end
+
     def log(message, uri = @uri, severity = Logger::WARN)
       message = "#{message.class}: #{message.message}" if message.is_a? Exception
       @logger.add(severity, "[Micky] #{@request_class_name.upcase} #{uri} - #{message}")

data/lib/micky/response.rb

@@ -5,9 +5,15 @@ module Micky
   class Response < SimpleDelegator
     attr_reader :uri
 
-    def initialize(response, uri)
+    def initialize(response, uri, truncated: false)
       super(response)
       @uri = uri
+      @truncated = truncated
+    end
+
+    # True when the body was cut at `max_response_size`
+    def truncated?
+      @truncated
     end
 
     def data

data/lib/micky/uri.rb

@@ -16,7 +16,9 @@ module Micky
       ::URI.parse(uri)
     rescue ::URI::InvalidURIError
       begin
-        ::URI.parse(::URI::Parser.new.escape(uri))
+        # ::URI::Parser is the RFC3986 parser, whose #escape is a deprecated shim
+        # that delegates to the RFC2396 one and warns under $VERBOSE
+        ::URI.parse(::URI::RFC2396_PARSER.escape(uri))
       rescue ::URI::InvalidURIError
       end
     end
@@ -25,7 +27,8 @@ module Micky
 
   module URI
     def self.extract(text)
-      ::URI.extract(text).select { |uri|
+      # Same as above: ::URI.extract is a deprecated shim over this
+      ::URI::RFC2396_PARSER.extract(text).select { |uri|
         begin
           ::URI.parse(uri).is_a? ::URI::HTTP
         rescue ::URI::InvalidURIError

data/lib/micky/version.rb

@@ -1,3 +1,3 @@
 module Micky
-  VERSION = '0.7.1'
+  VERSION = '0.8.1'
 end

data/lib/micky.rb

@@ -12,6 +12,9 @@ module Micky
     raise_errors: false,
     max_redirects: 20,
     timeout: 10,
+    total_timeout: 20,
+    max_response_size: nil,
+    truncate: false,
     skip_resolve: false,
     resolve_timeout: 5,
     oauth: {},

data/test/max_response_size_test.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+describe 'Micky max_response_size' do
+  it 'reads the whole body when the option is not set' do
+    response = Micky.get(server.url('/ok'))
+    assert_equal 1000, response.body.bytesize
+    refute response.truncated?
+  end
+
+  it 'leaves a body under the limit alone' do
+    response = Micky.get(server.url('/ok'), max_response_size: 100_000)
+    assert_equal 1000, response.body.bytesize
+    refute response.truncated?
+  end
+
+  it 'accepts a body exactly at the limit' do
+    response = Micky.get(server.url('/ok'), max_response_size: 1000)
+    assert_equal 1000, response.body.bytesize
+    refute response.truncated?
+  end
+
+  describe 'when the server sends more than the limit' do
+    let(:limit) { 50_000 }
+
+    it 'returns nil' do
+      assert_nil Micky.get(server.url('/flood'), max_response_size: limit)
+    end
+
+    it 'raises Micky::TooLargeResponse when asked to raise' do
+      error = assert_raises(Micky::TooLargeResponse) do
+        Micky.get(server.url('/flood'), max_response_size: limit, raise_errors: true)
+      end
+      assert_equal 'Response larger than 50000 bytes', error.message
+    end
+
+    it 'gives up as soon as it has read the limit, rather than draining the server' do
+      # Unbounded, this reads a gigabyte
+      assert_operator elapsed { Micky.get(server.url('/flood'), max_response_size: limit) }, :<, 1.0
+    end
+
+    describe 'with truncate: true' do
+      let(:response) { Micky.get(server.url('/flood'), max_response_size: limit, truncate: true) }
+
+      it 'returns the first bytes up to the limit' do
+        assert_equal limit, response.body.bytesize
+        assert response.truncated?
+      end
+
+      it 'does not resume reading when the body is asked for again' do
+        response.body
+        assert_equal limit, response.body.bytesize
+      end
+
+      it 'reports a content length that matches what it holds' do
+        assert_equal limit, response.content_length
+      end
+
+      it 'returns as soon as it has enough, rather than draining the server' do
+        assert_operator elapsed { response }, :<, 1.0
+      end
+
+      it 'counts what it keeps, not what came off the wire, when Net::HTTP decompresses' do
+        response = Micky.get(server.url('/gzipped-flood'), max_response_size: limit, truncate: true)
+        assert_equal limit, response.body.bytesize
+        assert response.body.start_with?('xxx')
+        assert response.truncated?
+      end
+    end
+  end
+
+  it 'caps a redirect body without treating it as too large' do
+    # The 302 itself carries a gigabyte; only the hop after it is a real response
+    time = elapsed {
+      response = Micky.get(server.url('/fat-redirect'), max_response_size: 50_000)
+      assert_equal 1000, response.body.bytesize
+      refute response.truncated?
+    }
+    assert_operator time, :<, 2.0
+  end
+
+  it 'keeps an empty body empty rather than nil' do
+    assert_equal '', Micky.get(server.url('/chunked-empty')).body
+    assert_equal '', Micky.get(server.url('/chunked-empty'), max_response_size: 100).body
+  end
+
+  it 'keeps a HEAD body nil' do
+    assert_nil Micky.head(server.url('/ok'), max_response_size: 100).body
+  end
+end

data/test/redirect_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+describe 'Micky redirects' do
+  # The test server listens on a random port, so a redirect that loses the port
+  # goes to 127.0.0.1:80 and fails
+  it 'keeps the port when the Location is host-relative' do
+    response = Micky.get(server.url('/host-relative-redirect'))
+    assert_equal 1000, response.body.bytesize
+  end
+
+  it 'keeps the port when the Location is path-relative' do
+    response = Micky.get(server.url('/dir/path-relative-redirect'))
+    assert_equal 1000, response.body.bytesize
+  end
+
+  it 'redirects to the resolved URL' do
+    log = StringIO.new
+    Micky.logger = Logger.new(log, level: Logger::DEBUG)
+    Micky.get(server.url('/host-relative-redirect'))
+    assert_includes log.string, "302 redirect to #{server.url('/ok')}"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,115 @@
+require 'minitest/autorun'
+require 'micky'
+require 'socket'
+require 'logger'
+
+# WebMock and friends intercept above Net::HTTP’s body reading, so they can’t
+# test how many bytes come off the socket or how long we wait. This serves real
+# HTTP over a real socket instead.
+class TestServer
+  attr_reader :port
+
+  RESPONSES = {
+    # A small, ordinary response
+    '/ok' => ->(socket) {
+      body = 'hello' * 200
+      socket.write "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: #{body.bytesize}\r\n\r\n"
+      socket.write body
+    },
+    '/dir/ok' => ->(socket) { RESPONSES['/ok'].call(socket) },
+    # A 200 whose chunked body is empty; Net::HTTP yields no chunk for it
+    '/chunked-empty' => ->(socket) {
+      socket.write "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nTransfer-Encoding: chunked\r\n\r\n0\r\n\r\n"
+    },
+    # Redirects with a host-relative Location
+    '/host-relative-redirect' => ->(socket) {
+      socket.write "HTTP/1.1 302 Found\r\nLocation: /ok\r\nContent-Length: 0\r\n\r\n"
+    },
+    # Redirects with a path-relative Location, to /dir/ok
+    '/dir/path-relative-redirect' => ->(socket) {
+      socket.write "HTTP/1.1 302 Found\r\nLocation: ok\r\nContent-Length: 0\r\n\r\n"
+    },
+    # Streams for as long as anyone reads
+    '/flood' => ->(socket) {
+      socket.write "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 1000000000\r\n\r\n"
+      loop { socket.write('x' * 8192) }
+    },
+    # One byte at a time, never idle long enough to trip a per-read timeout
+    '/drip' => ->(socket) {
+      socket.write "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 100000\r\n\r\n"
+      loop { socket.write('x'); socket.flush; sleep 0.2 }
+    },
+    # A redirect that itself carries a huge body
+    '/fat-redirect' => ->(socket) {
+      socket.write "HTTP/1.1 302 Found\r\nLocation: /ok\r\nContent-Length: 1000000000\r\n\r\n"
+      loop { socket.write('x' * 8192) }
+    },
+    # gzip, so Net::HTTP’s transparent decoding is in the path
+    '/gzipped-flood' => ->(socket) {
+      require 'zlib'
+      socket.write "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Encoding: gzip\r\n\r\n"
+      writer = Zlib::GzipWriter.new(socket)
+      loop { writer.write('x' * 8192) }
+    },
+  }
+
+  def initialize
+    @server = TCPServer.new('127.0.0.1', 0)
+    @port = @server.addr[1]
+    @thread = Thread.new { accept_loop }
+    @thread.abort_on_exception = false
+  end
+
+  def url(path) = "http://127.0.0.1:#{@port}#{path}"
+
+  def stop
+    @thread.kill
+    @server.close
+  end
+
+private
+
+  def accept_loop
+    loop do
+      socket = @server.accept
+      Thread.start(socket) do |s|
+        begin
+          path = s.gets.to_s.split(' ')[1]
+          while (line = s.gets) && line != "\r\n"; end
+          RESPONSES.fetch(path, ->(so) { so.write("HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\n\r\n") }).call(s)
+        rescue StandardError, Timeout::Error
+          # The client hung up, as most of these specs expect
+        ensure
+          s.close rescue nil
+        end
+      end
+    end
+  end
+end
+
+class MickyTest < Minitest::Spec
+  def self.server
+    @server ||= begin
+      server = TestServer.new
+      Minitest.after_run { server.stop }
+      server
+    end
+  end
+
+  def server = self.class.server
+
+  def setup
+    Micky::DEFAULTS.each { |key, value| Micky.public_send("#{key}=", value) }
+    Micky.logger = Logger.new(nil)
+    Micky.skip_resolve = true
+  end
+
+  def elapsed
+    t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    yield
+    Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+  end
+end
+
+# Every `describe` block inherits the server and the defaults reset above
+Minitest::Spec.register_spec_type(//, MickyTest)

data/test/total_timeout_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+describe 'Micky total_timeout' do
+  it 'defaults to 20 seconds' do
+    assert_equal 20, Micky.total_timeout
+  end
+
+  it 'leaves a fast response alone' do
+    assert_equal 1000, Micky.get(server.url('/ok'), total_timeout: 5).body.bytesize
+  end
+
+  describe 'against a server that drips bytes slower than it is read' do
+    # Every read succeeds, so `timeout` never fires however low it is set
+    let(:opts) { { timeout: 5, total_timeout: 1 } }
+
+    it 'gives up at the deadline' do
+      assert_in_delta 1, elapsed { Micky.get(server.url('/drip'), **opts) }, 0.5
+    end
+
+    it 'returns nil by default' do
+      assert_nil Micky.get(server.url('/drip'), **opts)
+    end
+
+    it 'raises Micky::TotalTimeout when asked to raise' do
+      assert_raises(Micky::TotalTimeout) do
+        Micky.get(server.url('/drip'), raise_errors: true, **opts)
+      end
+    end
+
+    it 'never returns without the deadline, which is what makes it necessary' do
+      assert_raises(Timeout::Error) do
+        Timeout.timeout(2) { Micky.get(server.url('/drip'), timeout: 5, total_timeout: nil) }
+      end
+    end
+  end
+
+  it 'does not relabel an enclosing block’s expiry as its own' do
+    assert_raises(ArgumentError) do
+      Timeout.timeout(0.2, ArgumentError) do
+        Micky.get(server.url('/drip'), timeout: 5, total_timeout: 30)
+      end
+    end
+  end
+end

data/test/uri_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+describe 'Micky.URI' do
+  # Ruby only prints the deprecation under $VERBOSE, so turn it on to see it
+  def without_warnings
+    verbose, $VERBOSE = $VERBOSE, true
+    _, err = capture_io { yield }
+    err
+  ensure
+    $VERBOSE = verbose
+  end
+
+  it 'escapes a URL that ::URI.parse rejects' do
+    uri = nil
+    err = without_warnings { uri = Micky.URI('http://example.com/a b?x=1|2') }
+    assert_equal 'http://example.com/a%20b?x=1%7C2', uri.to_s
+    assert_empty err
+  end
+
+  it 'extracts http URLs from text' do
+    urls = nil
+    err = without_warnings { urls = Micky::URI.extract('see http://a.com and ftp://c.com') }
+    assert_equal ['http://a.com'], urls
+    assert_empty err
+  end
+end

metadata

@@ -1,14 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: micky
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.1
 platform: ruby
 authors:
-- Rafaël Blais Masson
+- Rafael Masson
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: uri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -23,6 +65,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: Micky makes simple HTTP requests (GET/HEAD), follows redirects, handles
   exceptions (invalid hosts/URIs, server errors, timeouts, redirect loops), automatically
   parses responses (JSON, etc.), is very lightweight, and has no dependency.
@@ -32,8 +88,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- Gemfile
+- ".github/workflows/ci.yml"
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -43,11 +98,18 @@ files:
 - lib/micky/response.rb
 - lib/micky/uri.rb
 - lib/micky/version.rb
-- micky.gemspec
-homepage: http://github.com/rafBM/micky
+- test/max_response_size_test.rb
+- test/redirect_test.rb
+- test/test_helper.rb
+- test/total_timeout_test.rb
+- test/uri_test.rb
+homepage: https://github.com/rafbm/micky
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/rafbm/micky
+  source_code_uri: https://github.com/rafbm/micky
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -55,14 +117,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Lightweight and worry-free HTTP client
 test_files: []

data/.gitignore

@@ -1,17 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp

data/Gemfile

@@ -1,2 +0,0 @@
-source 'https://rubygems.org'
-gemspec

data/micky.gemspec

@@ -1,26 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'micky/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'micky'
-  spec.version       = Micky::VERSION
-  spec.authors       = ['Rafaël Blais Masson']
-  spec.email         = ['rafbmasson@gmail.com']
-  spec.description   =
-    'Micky makes simple HTTP requests (GET/HEAD), follows redirects, handles ' \
-    'exceptions (invalid hosts/URIs, server errors, timeouts, redirect loops), ' \
-    'automatically parses responses (JSON, etc.), is very lightweight, and has no ' \
-    'dependency.'
-  spec.summary       = 'Lightweight and worry-free HTTP client'
-  spec.homepage      = 'http://github.com/rafBM/micky'
-  spec.license       = 'MIT'
-
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ['lib']
-
-  spec.add_development_dependency 'rake'
-end