down 5.0.0 → 5.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1f7a1532b638ed92acdb3bdf74211dbd022e7a0de37d1fdbc25f665337d4bf1
-  data.tar.gz: 7bbc2684d53e278376981b4dd4741c49bc0d8da0990ece28fb03776f39aea6fe
+  metadata.gz: e0544a70de3afab2a00c68df6923572a5533f05a0964b8c5186728019d04e55b
+  data.tar.gz: 3474da6a6c7a182aa02deb72139002ebf97ac98bee9c4a833de2b0413e373924
 SHA512:
-  metadata.gz: 6a3e62293c5fa1e5b43a5c835af3804ab8307babfb573179057ec279239b72a16ff74b2b2e96df9da033a3e4e13be4af6adeb8ec00dd73a27f75942b646419de
-  data.tar.gz: d267672bb2468c8998e271ff3849908c7beead00d8b9777799e6bc0abd1ab51ccf14d5c567c16f3bb30a41eb3c57b66ffbc2755d333055fba972d327a865acb4
+  metadata.gz: 64d22c0a25ddf60f2dea37cb03264ec5770a8c7877fb7a843052abca4b043ba9d2d0c8eed830fc2cec97bb852338b114e2907c357aaf4b68aad26a6860459f67
+  data.tar.gz: 992209a7e4201cab464958bac0960ba4a6dc0344cd410b7ceaec2a02b89ebc1bd876396349204bb0bfe175a279fbdb41900c9fee85eee7e98d74eec7afa2e7a0

data/CHANGELOG.md

@@ -1,3 +1,61 @@
+## 5.4.0 (2022-12-26)
+
+* Add new HTTPX backend, which supports HTTP/2 protocol among other features (@HoneyryderChuck)
+
+## 5.3.1 (2022-03-25)
+
+* Correctly split cookie headers on `;` instead of `,` when forwarding them on redirects (@ermolaev)
+
+## 5.3.0 (2022-02-20)
+
+* Add `:extension` argument to `Down.download` for overriding tempfile extension (@razum2um)
+
+* Normalize response header names for http.rb and wget backends (@zarqman)
+
+## 5.2.4 (2021-09-12)
+
+* Keep original cookies between redirections (@antprt)
+
+## 5.2.3 (2021-08-03)
+
+* Bump addressable version requirement to 2.8+ to remediate vulnerability (@aldodelgado)
+
+## 5.2.2 (2021-05-27)
+
+* Add info about received content length in `Down::TooLarge` error (@evheny0)
+
+* Relax http.rb constraint to allow versions 5.x (@mgrunberg)
+
+## 5.2.1 (2021-04-26)
+
+* Raise `Down::NotModified` on 304 response status in `Down::NetHttp#open` (@ellafeldmann)
+
+## 5.2.0 (2020-09-20)
+
+* Add `:uri_normalizer` option to `Down::NetHttp` (@janko)
+
+* Add `:http_basic_authentication` option to `Down::NetHttp#open` (@janko)
+
+* Fix uninitialized instance variables warnings in `Down::ChunkedIO` (@janko)
+
+* Handle unknown HTTP error codes in `Down::NetHttp` (@darndt)
+
+## 5.1.1 (2020-02-04)
+
+* Fix keyword arguments warnings on Ruby 2.7 in `Down.download` and `Down.open` (@janko)
+
+## 5.1.0 (2020-01-09)
+
+* Fix keyword arguments warnings on Ruby 2.7 (@janko)
+
+* Fix `FrozenError` exception in `Down::ChunkedIO#readpartial` (@janko)
+
+* Deprecate passing headers as top-level options in `Down::NetHttp` (@janko)
+
+## 5.0.1 (2019-12-20)
+
+* In `Down::NetHttp` only use Addressable normalization if `URI.parse` fails (@coding-chimp)
+
 ## 5.0.0 (2019-09-26)
 
 * Change `ChunkedIO#each_chunk` to return chunks in original encoding (@janko)

data/README.md

@@ -1,13 +1,13 @@
 # Down
 
 Down is a utility tool for streaming, flexible and safe downloading of remote
-files. It can use [open-uri] + `Net::HTTP`, [http.rb] or `wget` as the backend
-HTTP library.
+files. It can use [open-uri] + `Net::HTTP`, [http.rb], [HTTPX], or `wget` as
+the backend HTTP library.
 
 ## Installation
 
 ```rb
-gem "down", "~> 4.4"
+gem "down", "~> 5.0"
 ```
 
 ## Downloading
@@ -63,6 +63,13 @@ Down.download("http://example.com/image.jpg", destination: "/path/to/destination
 In this case `Down.download` won't have any return value, so if you need a File
 object you'll have to create it manually.
 
+You can also keep the tempfile, but override the extension:
+
+```rb
+tempfile = Down.download("http://example.com/some/file", extension: "txt")
+File.extname(tempfile.path) #=> ".txt"
+```
+
 ### Basic authentication
 
 `Down.download` and `Down.open` will automatically detect and apply HTTP basic
@@ -157,7 +164,7 @@ You can access the response status and headers of the HTTP request that was made
 ```rb
 remote_file = Down.open("http://example.com/image.jpg")
 remote_file.data[:status]   #=> 200
-remote_file.data[:headers]  #=> { ... }
+remote_file.data[:headers]  #=> { "Content-Type" => "image/jpeg", ... } (header names are normalized)
 remote_file.data[:response] # returns the response object
 ```
 
@@ -212,6 +219,7 @@ the `Down::Error` subclasses. This is Down's exception hierarchy:
   * `Down::TooLarge`
   * `Down::InvalidUrl`
   * `Down::TooManyRedirects`
+  * `Down::NotModified`
   * `Down::ResponseError`
     * `Down::ClientError`
       * `Down::NotFound`
@@ -226,6 +234,7 @@ The following backends are available:
 
 * [Down::NetHttp](#downnethttp) (default)
 * [Down::Http](#downhttp)
+* [Down::Httpx](#downhttpx)
 * [Down::Wget](#downwget)
 
 You can use the backend directly:
@@ -251,10 +260,10 @@ Down.open("...")
 ### Down::NetHttp
 
 The `Down::NetHttp` backend implements downloads using [open-uri] and
-[Net::HTTP].
+[Net::HTTP] standard libraries.
 
 ```rb
-gem "down", "~> 4.4"
+gem "down", "~> 5.0"
 ```
 ```rb
 require "down/net_http"
@@ -333,6 +342,18 @@ Down::NetHttp.open("http://example.com/image.jpg",
   ssl_verify_mode: OpenSSL::SSL::VERIFY_PEER)
 ```
 
+#### URI normalization
+
+If the URL isn't parseable by `URI.parse`, `Down::NetHttp` will
+attempt to normalize the URL using [Addressable::URI], URI-escaping
+any potentially unescaped characters. You can change the normalizer
+via the `:uri_normalizer` option:
+
+```rb
+# this skips URL normalization
+Down::NetHttp.download("http://example.com/image.jpg", uri_normalizer: -> (url) { url })
+```
+
 #### Additional options
 
 Any additional options passed to `Down.download` will be forwarded to
@@ -358,8 +379,8 @@ net_http.open("http://example.com/image.jpg")
 The `Down::Http` backend implements downloads using the [http.rb] gem.
 
 ```rb
-gem "down", "~> 4.4"
-gem "http", "~> 4.0"
+gem "down", "~> 5.0"
+gem "http", "~> 5.0"
 ```
 ```rb
 require "down/http"
@@ -422,13 +443,35 @@ down = Down::Http.new(method: :post)
 down.download("http://example.org/image.jpg")
 ```
 
+### Down::Httpx
+
+The `Down::Httpx` backend implements downloads using the [HTTPX] gem, which
+supports the HTTP/2 protocol, in addition to many other features.
+
+```rb
+gem "down", "~> 5.0"
+gem "httpx", "~> 0.22"
+```
+```rb
+require "down/httpx"
+
+tempfile = Down::Httpx.download("http://nature.com/forest.jpg")
+tempfile #=> #<Tempfile:/var/folders/k7/6zx6dx6x7ys3rv3srh0nyfj00000gn/T/20150925-55456-z7vxqz.jpg>
+
+io = Down::Httpx.open("http://nature.com/forest.jpg")
+io #=> #<Down::ChunkedIO ...>
+```
+
+It's implemented in much of the same way as `Down::Http`, so be sure to check
+its docs for ways to pass additional options.
+
 ### Down::Wget (experimental)
 
 The `Down::Wget` backend implements downloads using the `wget` command line
 utility.
 
 ```rb
-gem "down", "~> 4.4"
+gem "down", "~> 5.0"
 gem "posix-spawn" # omit if on JRuby
 gem "http_parser.rb"
 ```
@@ -470,24 +513,30 @@ wget.open("http://nature.com/forest.jpg")
 
 ## Supported Ruby versions
 
-* MRI 2.2
 * MRI 2.3
 * MRI 2.4
 * MRI 2.5
 * MRI 2.6
-* JRuby
+* MRI 2.7
+* MRI 3.0
+* MRI 3.1
+* JRuby 9.3
 
 ## Development
 
-You can run tests with
+Tests require that a [httpbin] server is running locally, which you can do via Docker:
+
+```sh
+$ docker pull kennethreitz/httpbin
+$ docker run -p 80:80 kennethreitz/httpbin
+```
+
+Then you can run tests:
 
 ```
 $ bundle exec rake test
 ```
 
-The test suite pulls and runs [kennethreitz/httpbin] as a Docker container, so
-you'll need to have Docker installed and running.
-
 ## License
 
 [MIT](LICENSE.txt)
@@ -495,5 +544,6 @@ you'll need to have Docker installed and running.
 [open-uri]: http://ruby-doc.org/stdlib-2.3.0/libdoc/open-uri/rdoc/OpenURI.html
 [Net::HTTP]: https://ruby-doc.org/stdlib-2.4.1/libdoc/net/http/rdoc/Net/HTTP.html
 [http.rb]: https://github.com/httprb/http
+[HTTPX]: https://github.com/HoneyryderChuck/httpx
 [Addressable::URI]: https://github.com/sporkmonger/addressable
-[kennethreitz/httpbin]: https://github.com/kennethreitz/httpbin
+[httpbin]: https://github.com/postmanlabs/httpbin

data/down.gemspec

@@ -4,7 +4,7 @@ Gem::Specification.new do |spec|
   spec.name         = "down"
   spec.version      = Down::VERSION
 
-  spec.required_ruby_version = ">= 2.1"
+  spec.required_ruby_version = ">= 2.3"
 
   spec.summary      = "Robust streaming downloads using Net::HTTP, HTTP.rb or wget."
   spec.homepage     = "https://github.com/janko/down"
@@ -15,13 +15,19 @@ Gem::Specification.new do |spec|
   spec.files        = Dir["README.md", "LICENSE.txt", "CHANGELOG.md", "*.gemspec", "lib/**/*.rb"]
   spec.require_path = "lib"
 
-  spec.add_dependency "addressable", "~> 2.5"
+  spec.add_dependency "addressable", "~> 2.8"
 
   spec.add_development_dependency "minitest", "~> 5.8"
   spec.add_development_dependency "mocha", "~> 1.5"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "http", "~> 4.0"
+  spec.add_development_dependency "httpx", "~> 0.22", ">= 0.22.2"
+  # http 5.0 drop support of ruby 2.3 and 2.4. We still support those versions.
+  if RUBY_VERSION >= "2.5"
+    spec.add_development_dependency "http", "~> 5.0"
+  else
+    spec.add_development_dependency "http", "~> 4.3"
+  end
   spec.add_development_dependency "posix-spawn" unless RUBY_ENGINE == "jruby"
-  spec.add_development_dependency "http_parser.rb"
-  spec.add_development_dependency "docker-api"
+  spec.add_development_dependency "http_parser.rb" unless RUBY_ENGINE == "jruby"
+  spec.add_development_dependency "warning" if RUBY_VERSION >= "2.4"
 end

data/lib/down/backend.rb

@@ -9,12 +9,12 @@ require "fileutils"
 
 module Down
   class Backend
-    def self.download(*args, &block)
-      new.download(*args, &block)
+    def self.download(*args, **options, &block)
+      new.download(*args, **options, &block)
     end
 
-    def self.open(*args, &block)
-      new.open(*args, &block)
+    def self.open(*args, **options, &block)
+      new.open(*args, **options, &block)
     end
 
     private
@@ -29,5 +29,12 @@ module Down
 
       nil
     end
+
+    def normalize_headers(response_headers)
+      response_headers.inject({}) do |headers, (downcased_name, value)|
+        name = downcased_name.split("-").map(&:capitalize).join("-")
+        headers.merge!(name => value)
+      end
+    end
   end
 end

data/lib/down/chunked_io.rb

@@ -36,6 +36,8 @@ module Down
       @rewindable = rewindable
       @buffer     = nil
       @position   = 0
+      @next_chunk = nil
+      @closed     = false
 
       retrieve_chunk # fetch first chunk so that we know whether the file is empty
     end
@@ -63,7 +65,9 @@ module Down
     def read(length = nil, outbuf = nil)
       fail IOError, "closed stream" if closed?
 
-      data             = outbuf.to_s.clear.force_encoding(Encoding::BINARY)
+      data   = outbuf.clear.force_encoding(Encoding::BINARY) if outbuf
+      data ||= "".b
+
       remaining_length = length
 
       until remaining_length == 0 || eof?
@@ -142,7 +146,8 @@ module Down
     # or the next chunk. This is useful when you don't care about the size of
     # chunks and you want to minimize string allocations.
     #
-    # With `length` argument returns maximum of that amount of bytes.
+    # With `maxlen` argument returns maximum of that amount of bytes (default
+    # is 16KB).
     #
     # With `outbuf` argument each call will return that same string object,
     # where the value is replaced with retrieved content.
@@ -154,7 +159,8 @@ module Down
       maxlen ||= 16*1024
 
       data   = cache.read(maxlen, outbuf) if cache && !cache.eof?
-      data ||= outbuf.to_s.clear
+      data ||= outbuf.clear.force_encoding(Encoding::BINARY) if outbuf
+      data ||= "".b
 
       return data if maxlen == 0
 

data/lib/down/errors.rb

@@ -13,11 +13,14 @@ module Down
   # raised when the number of redirects was larger than the specified maximum
   class TooManyRedirects < Error; end
 
+  # raised when the requested resource has not been modified
+  class NotModified < Error; end
+
   # raised when response returned 4xx or 5xx response
   class ResponseError < Error
     attr_reader :response
 
-    def initialize(message, response: nil)
+    def initialize(message, response = nil)
       super(message)
       @response = response
     end

data/lib/down/http.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-gem "http", ">= 2.1.0", "< 5"
+gem "http", ">= 2.1.0", "< 6"
 
 require "http"
 
@@ -12,7 +12,7 @@ module Down
   # Provides streaming downloads implemented with HTTP.rb.
   class Http < Backend
     # Initializes the backend with common defaults.
-    def initialize(options = {}, &block)
+    def initialize(**options, &block)
       @method = options.delete(:method) || :get
       @client = HTTP
         .headers("User-Agent" => "Down/#{Down::VERSION}")
@@ -25,16 +25,16 @@ module Down
 
     # Downlods the remote file to disk. Accepts HTTP.rb options via a hash or a
     # block, and some additional options as well.
-    def download(url, max_size: nil, progress_proc: nil, content_length_proc: nil, destination: nil, **options, &block)
+    def download(url, max_size: nil, progress_proc: nil, content_length_proc: nil, destination: nil, extension: nil, **options, &block)
       response = request(url, **options, &block)
 
       content_length_proc.call(response.content_length) if content_length_proc && response.content_length
 
       if max_size && response.content_length && response.content_length > max_size
-        raise Down::TooLarge, "file is too large (max is #{max_size/1024/1024}MB)"
+        raise Down::TooLarge, "file is too large (#{response.content_length/1024/1024}MB, max is #{max_size/1024/1024}MB)"
       end
 
-      extname  = File.extname(response.uri.path)
+      extname  = extension ? ".#{extension}" : File.extname(response.uri.path)
       tempfile = Tempfile.new(["down-http", extname], binmode: true)
 
       stream_body(response) do |chunk|
@@ -44,7 +44,7 @@ module Down
         progress_proc.call(tempfile.size) if progress_proc
 
         if max_size && tempfile.size > max_size
-          raise Down::TooLarge, "file is too large (max is #{max_size/1024/1024}MB)"
+          raise Down::TooLarge, "file is too large (#{tempfile.size/1024/1024}MB, max is #{max_size/1024/1024}MB)"
         end
       end
 
@@ -52,7 +52,7 @@ module Down
 
       tempfile.extend Down::Http::DownloadedFile
       tempfile.url     = response.uri.to_s
-      tempfile.headers = response.headers.to_h
+      tempfile.headers = normalize_headers(response.headers.to_h)
 
       download_result(tempfile, destination)
     rescue
@@ -71,7 +71,11 @@ module Down
         size:       response.content_length,
         encoding:   response.content_type.charset,
         rewindable: rewindable,
-        data:       { status: response.code, headers: response.headers.to_h, response: response },
+        data:       {
+          status:   response.code,
+          headers:  normalize_headers(response.headers.to_h),
+          response: response
+        },
       )
     end
 
@@ -106,7 +110,7 @@ module Down
 
     # Raises non-sucessful response as a Down::ResponseError.
     def response_error!(response)
-      args = [response.status.to_s, response: response]
+      args = [response.status.to_s, response]
 
       case response.code
       when 404      then raise Down::NotFound.new(*args)

data/lib/down/httpx.rb

@@ -0,0 +1,175 @@
+# frozen-string-literal: true
+
+require "uri"
+require "tempfile"
+require "httpx"
+
+require "down/backend"
+
+
+module Down
+  # Provides streaming downloads implemented with HTTPX.
+  class Httpx < Backend
+    # Initializes the backend
+
+    USER_AGENT = "Down/#{Down::VERSION}"
+
+    def initialize(**options, &block)
+      @method = options.delete(:method) || :get
+      headers = options.delete(:headers) || {}
+      @client = HTTPX
+          .plugin(:follow_redirects, max_redirects: 2)
+          .plugin(:basic_authentication)
+          .plugin(:stream)
+          .with(
+            headers: { "user-agent": USER_AGENT }.merge(headers),
+            timeout: { connect_timeout: 30, write_timeout: 30, read_timeout: 30 },
+            **options
+          )
+
+      @client = block.call(@client) if block
+    end
+
+
+    # Downlods the remote file to disk. Accepts HTTPX options via a hash or a
+    # block, and some additional options as well.
+    def download(url, max_size: nil, progress_proc: nil, content_length_proc: nil, destination: nil, extension: nil, **options, &block)
+      client = @client
+
+      response = request(client, url, **options, &block)
+
+      content_length = nil
+
+      if response.headers.key?("content-length")
+        content_length = response.headers["content-length"].to_i
+
+        content_length_proc.call(content_length) if content_length_proc
+
+        if max_size && content_length > max_size
+          response.close
+          raise Down::TooLarge, "file is too large (#{content_length/1024/1024}MB, max is #{max_size/1024/1024}MB)"
+        end
+      end
+
+      extname  = extension ? ".#{extension}" : File.extname(response.uri.path)
+      tempfile = Tempfile.new(["down-http", extname], binmode: true)
+
+      stream_body(response) do |chunk|
+        tempfile.write(chunk)
+        chunk.clear # deallocate string
+
+        progress_proc.call(tempfile.size) if progress_proc
+
+        if max_size && tempfile.size > max_size
+          raise Down::TooLarge, "file is too large (#{tempfile.size/1024/1024}MB, max is #{max_size/1024/1024}MB)"
+        end
+      end
+
+      tempfile.open # flush written content
+
+      tempfile.extend DownloadedFile
+      tempfile.url     = response.uri.to_s
+      tempfile.headers = normalize_headers(response.headers.to_h)
+      tempfile.content_type = response.content_type.mime_type
+      tempfile.charset = response.body.encoding
+
+      download_result(tempfile, destination)
+    rescue
+      tempfile.close! if tempfile
+      raise
+    end
+
+    # Starts retrieving the remote file and returns an IO-like object which
+    # downloads the response body on-demand. Accepts HTTP.rb options via a hash
+    # or a block.
+    def open(url, rewindable: true, **options, &block)
+      response = request(@client, url, stream: true, **options, &block)
+      size = response.headers["content-length"]
+      size = size.to_i if size
+      Down::ChunkedIO.new(
+        chunks:     enum_for(:stream_body, response),
+        size:       size,
+        encoding:   response.body.encoding,
+        rewindable: rewindable,
+        data:       {
+          status:   response.status,
+          headers:  normalize_headers(response.headers.to_h),
+          response: response
+        },
+      )
+    end
+
+    private
+
+    # Yields chunks of the response body to the block.
+    def stream_body(response, &block)
+      response.each(&block)
+    rescue => exception
+      request_error!(exception)
+    end
+
+    def request(client, url, method: @method, **options, &block)
+      response = send_request(client, method, url, **options, &block)
+      response.raise_for_status
+      response_error!(response) unless (200..299).include?(response.status)
+      response
+    rescue HTTPX::HTTPError
+      response_error!(response)
+    rescue => error
+      request_error!(error)
+    end
+
+    def send_request(client, method, url, **options, &block)
+      uri = URI(url)
+      client = @client
+      if uri.user || uri.password
+        client = client.basic_auth(uri.user, uri.password)
+        uri.user = uri.password = nil
+      end
+      client = block.call(client) if block
+
+      client.request(method, uri, stream: true, **options)
+    rescue => exception
+      request_error!(exception)
+    end
+
+    # Raises non-sucessful response as a Down::ResponseError.
+    def response_error!(response)
+      args = [response.status.to_s, response]
+
+      case response.status
+      when 300..399 then raise Down::TooManyRedirects, "too many redirects"
+      when 404      then raise Down::NotFound.new(*args)
+      when 400..499 then raise Down::ClientError.new(*args)
+      when 500..599 then raise Down::ServerError.new(*args)
+      else               raise Down::ResponseError.new(*args)
+      end
+    end
+
+    # Re-raise HTTP.rb exceptions as Down::Error exceptions.
+    def request_error!(exception)
+      case exception
+      when URI::Error, HTTPX::UnsupportedSchemeError
+        raise Down::InvalidUrl, exception.message
+      when HTTPX::ConnectionError
+        raise Down::ConnectionError, exception.message
+      when HTTPX::TimeoutError
+        raise Down::TimeoutError, exception.message
+      when OpenSSL::SSL::SSLError
+        raise Down::SSLError, exception.message
+      else
+        raise exception
+      end
+    end
+
+    # Defines some additional attributes for the returned Tempfile.
+    module DownloadedFile
+      attr_accessor :url, :headers, :charset, :content_type
+
+      def original_filename
+        Utils.filename_from_content_disposition(headers["Content-Disposition"]) ||
+        Utils.filename_from_path(URI.parse(url).path)
+      end
+    end
+  end
+end

data/lib/down/net_http.rb

@@ -12,27 +12,35 @@ require "fileutils"
 module Down
   # Provides streaming downloads implemented with Net::HTTP and open-uri.
   class NetHttp < Backend
+    URI_NORMALIZER = -> (url) do
+      addressable_uri = Addressable::URI.parse(url)
+      addressable_uri.normalize.to_s
+    end
+
     # Initializes the backend with common defaults.
-    def initialize(options = {})
-      @options = {
-        "User-Agent" => "Down/#{Down::VERSION}",
-        max_redirects: 2,
-        open_timeout:  30,
-        read_timeout:  30,
-      }.merge(options)
+    def initialize(*args, **options)
+      @options = merge_options({
+        headers:        { "User-Agent" => "Down/#{Down::VERSION}" },
+        max_redirects:  2,
+        open_timeout:   30,
+        read_timeout:   30,
+        uri_normalizer: URI_NORMALIZER,
+      }, *args, **options)
     end
 
     # Downloads a remote file to disk using open-uri. Accepts any open-uri
     # options, and a few more.
-    def download(url, options = {})
-      options = @options.merge(options)
+    def download(url, *args, **options)
+      options = merge_options(@options, *args, **options)
 
       max_size            = options.delete(:max_size)
       max_redirects       = options.delete(:max_redirects)
       progress_proc       = options.delete(:progress_proc)
       content_length_proc = options.delete(:content_length_proc)
       destination         = options.delete(:destination)
-      headers             = options.delete(:headers) || {}
+      headers             = options.delete(:headers)
+      uri_normalizer      = options.delete(:uri_normalizer)
+      extension           = options.delete(:extension)
 
       # Use open-uri's :content_lenth_proc or :progress_proc to raise an
       # exception early if the file is too large.
@@ -42,13 +50,13 @@ module Down
       open_uri_options = {
         content_length_proc: proc { |size|
           if size && max_size && size > max_size
-            raise Down::TooLarge, "file is too large (max is #{max_size/1024/1024}MB)"
+            raise Down::TooLarge, "file is too large (#{size/1024/1024}MB, max is #{max_size/1024/1024}MB)"
           end
           content_length_proc.call(size) if content_length_proc
         },
         progress_proc: proc { |current_size|
           if max_size && current_size > max_size
-            raise Down::TooLarge, "file is too large (max is #{max_size/1024/1024}MB)"
+            raise Down::TooLarge, "file is too large (#{current_size/1024/1024}MB, max is #{max_size/1024/1024}MB)"
           end
           progress_proc.call(current_size) if progress_proc
         },
@@ -74,7 +82,7 @@ module Down
       open_uri_options.merge!(options)
       open_uri_options.merge!(headers)
 
-      uri = ensure_uri(addressable_normalize(url))
+      uri = ensure_uri(normalize_uri(url, uri_normalizer: uri_normalizer))
 
       # Handle basic authentication in the remote URL.
       if uri.user || uri.password
@@ -86,7 +94,8 @@ module Down
       open_uri_file = open_uri(uri, open_uri_options, follows_remaining: max_redirects)
 
       # Handle the fact that open-uri returns StringIOs for small files.
-      tempfile = ensure_tempfile(open_uri_file, File.extname(open_uri_file.base_uri.path))
+      extname = extension ? ".#{extension}" : File.extname(open_uri_file.base_uri.path)
+      tempfile = ensure_tempfile(open_uri_file, extname)
       OpenURI::Meta.init tempfile, open_uri_file # add back open-uri methods
       tempfile.extend Down::NetHttp::DownloadedFile
 
@@ -95,13 +104,17 @@ module Down
 
     # Starts retrieving the remote file using Net::HTTP and returns an IO-like
     # object which downloads the response body on-demand.
-    def open(url, options = {})
-      uri     = ensure_uri(addressable_normalize(url))
-      options = @options.merge(options)
+    def open(url, *args, **options)
+      options = merge_options(@options, *args, **options)
+
+      max_redirects  = options.delete(:max_redirects)
+      uri_normalizer = options.delete(:uri_normalizer)
+
+      uri = ensure_uri(normalize_uri(url, uri_normalizer: uri_normalizer))
 
       # Create a Fiber that halts when response headers are received.
       request = Fiber.new do
-        net_http_request(uri, options) do |response|
+        net_http_request(uri, options, follows_remaining: max_redirects) do |response|
           Fiber.yield response
         end
       end
@@ -119,10 +132,7 @@ module Down
         on_close:   -> { request.resume }, # close HTTP connnection
         data: {
           status:   response.code.to_i,
-          headers:  response.each_header.inject({}) { |headers, (downcased_name, value)|
-                      name = downcased_name.split("-").map(&:capitalize).join("-")
-                      headers.merge!(name => value)
-                    },
+          headers:  normalize_headers(response.each_header),
           response: response,
         },
       )
@@ -131,7 +141,7 @@ module Down
     private
 
     # Calls open-uri's URI::HTTP#open method. Additionally handles redirects.
-    def open_uri(uri, options, follows_remaining: 0)
+    def open_uri(uri, options, follows_remaining:)
       uri.open(options)
     rescue OpenURI::HTTPRedirect => exception
       raise Down::TooManyRedirects, "too many redirects" if follows_remaining == 0
@@ -147,7 +157,11 @@ module Down
 
       # forward cookies on the redirect
       if !exception.io.meta["set-cookie"].to_s.empty?
-        options["Cookie"] = exception.io.meta["set-cookie"]
+        options["Cookie"] ||= ''
+        # Add new cookies avoiding duplication
+        new_cookies = exception.io.meta["set-cookie"].to_s.split(';').map(&:strip)
+        old_cookies = options["Cookie"].split(';')
+        options["Cookie"] = (old_cookies | new_cookies).join(';')
       end
 
       follows_remaining -= 1
@@ -186,18 +200,18 @@ module Down
     end
 
     # Makes a Net::HTTP request and follows redirects.
-    def net_http_request(uri, options, follows_remaining: options.fetch(:max_redirects, 2), &block)
+    def net_http_request(uri, options, follows_remaining:, &block)
       http, request = create_net_http(uri, options)
 
       begin
         response = http.start do
-          http.request(request) do |response|
-            unless response.is_a?(Net::HTTPRedirection)
-              yield response
+          http.request(request) do |resp|
+            unless resp.is_a?(Net::HTTPRedirection)
+              yield resp
               # In certain cases the caller wants to download only one portion
               # of the file and close the connection, so we tell Net::HTTP that
               # it shouldn't continue retrieving it.
-              response.instance_variable_set("@read", true)
+              resp.instance_variable_set("@read", true)
             end
           end
         end
@@ -205,7 +219,9 @@ module Down
         request_error!(exception)
       end
 
-      if response.is_a?(Net::HTTPRedirection)
+      if response.is_a?(Net::HTTPNotModified)
+        raise Down::NotModified
+      elsif response.is_a?(Net::HTTPRedirection)
         raise Down::TooManyRedirects if follows_remaining == 0
 
         # fail if redirect URI is not a valid http or https URL
@@ -251,12 +267,13 @@ module Down
       http.read_timeout = options[:read_timeout] if options.key?(:read_timeout)
       http.open_timeout = options[:open_timeout] if options.key?(:open_timeout)
 
-      headers = options.select { |key, value| key.is_a?(String) }
-      headers.merge!(options[:headers]) if options[:headers]
+      headers = options[:headers].to_h
       headers["Accept-Encoding"] = "" # Net::HTTP's inflater causes FiberErrors
 
       get = Net::HTTP::Get.new(uri.request_uri, headers)
-      get.basic_auth(uri.user, uri.password) if uri.user || uri.password
+
+      user, password = options[:http_basic_authentication] || [uri.user, uri.password]
+      get.basic_auth(user, password) if user || password
 
       [http, get]
     end
@@ -284,9 +301,10 @@ module Down
     end
 
     # Makes sure that the URL is properly encoded.
-    def addressable_normalize(url)
-      addressable_uri = Addressable::URI.parse(url)
-      addressable_uri.normalize.to_s
+    def normalize_uri(url, uri_normalizer:)
+      URI(url)
+    rescue URI::InvalidURIError
+      uri_normalizer.call(url)
     end
 
     # When open-uri raises an exception, it doesn't expose the response object.
@@ -295,7 +313,11 @@ module Down
     def rebuild_response_from_open_uri_exception(exception)
       code, message = exception.io.status
 
-      response_class = Net::HTTPResponse::CODE_TO_OBJ.fetch(code)
+      response_class = Net::HTTPResponse::CODE_TO_OBJ.fetch(code) do |c|
+        Net::HTTPResponse::CODE_CLASS_TO_OBJ.fetch(c[0]) do
+          Net::HTTPUnknownResponse
+        end
+      end
       response       = response_class.new(nil, code, message)
 
       exception.io.metas.each do |name, values|
@@ -310,7 +332,7 @@ module Down
       code    = response.code.to_i
       message = response.message.split(" ").map(&:capitalize).join(" ")
 
-      args = ["#{code} #{message}", response: response]
+      args = ["#{code} #{message}", response]
 
       case response.code.to_i
       when 404      then raise Down::NotFound.new(*args)
@@ -336,6 +358,24 @@ module Down
       end
     end
 
+    # Merge default and ad-hoc options, merging nested headers.
+    def merge_options(options, headers = {}, **new_options)
+      # Deprecate passing headers as top-level options, taking into account
+      # that Ruby 2.7+ accepts kwargs with string keys.
+      if headers.any?
+        warn %([Down::NetHttp] Passing headers as top-level options has been deprecated, use the :headers option instead, e.g: `Down::NetHttp.download(headers: { "Key" => "Value", ... }, ...)`)
+        new_options[:headers] = headers
+      elsif new_options.any? { |key, value| key.is_a?(String) }
+        warn %([Down::NetHttp] Passing headers as top-level options has been deprecated, use the :headers option instead, e.g: `Down::NetHttp.download(headers: { "Key" => "Value", ... }, ...)`)
+        new_options[:headers] = new_options.select { |key, value| key.is_a?(String) }
+        new_options.reject! { |key, value| key.is_a?(String) }
+      end
+
+      options.merge(new_options) do |key, value1, value2|
+        key == :headers ? value1.merge(value2) : value2
+      end
+    end
+
     # Defines some additional attributes for the returned Tempfile (on top of what
     # OpenURI::Meta already defines).
     module DownloadedFile

data/lib/down/version.rb

@@ -1,5 +1,5 @@
 # frozen-string-literal: true
 
 module Down
-  VERSION = "5.0.0"
+  VERSION = "5.4.0"
 end

data/lib/down/wget.rb

@@ -29,16 +29,16 @@ module Down
 
     # Downlods the remote file to disk. Accepts wget command-line options and
     # some additional options as well.
-    def download(url, *args, max_size: nil, content_length_proc: nil, progress_proc: nil, destination: nil, **options)
+    def download(url, *args, max_size: nil, content_length_proc: nil, progress_proc: nil, destination: nil, extension: nil, **options)
       io = open(url, *args, **options, rewindable: false)
 
       content_length_proc.call(io.size) if content_length_proc && io.size
 
       if max_size && io.size && io.size > max_size
-        raise Down::TooLarge, "file is too large (max is #{max_size/1024/1024}MB)"
+        raise Down::TooLarge, "file is too large (#{io.size/1024/1024}MB, max is #{max_size/1024/1024}MB)"
       end
 
-      extname  = File.extname(URI(url).path)
+      extname  = extension ? ".#{extension}" : File.extname(URI(url).path)
       tempfile = Tempfile.new(["down-wget", extname], binmode: true)
 
       until io.eof?
@@ -49,7 +49,7 @@ module Down
         progress_proc.call(tempfile.size) if progress_proc
 
         if max_size && tempfile.size > max_size
-          raise Down::TooLarge, "file is too large (max is #{max_size/1024/1024}MB)"
+          raise Down::TooLarge, "file is too large (#{tempfile.size/1024/1024}MB, max is #{max_size/1024/1024}MB)"
         end
       end
 
@@ -94,7 +94,7 @@ module Down
         raise Down::Error, "failed to parse response headers"
       end
 
-      headers = parser.headers
+      headers = normalize_headers(parser.headers)
       status  = parser.status_code
 
       content_length = headers["Content-Length"].to_i if headers["Content-Length"]

data/lib/down.rb

@@ -6,12 +6,12 @@ require "down/net_http"
 module Down
   module_function
 
-  def download(*args, &block)
-    backend.download(*args, &block)
+  def download(*args, **options, &block)
+    backend.download(*args, **options, &block)
   end
 
-  def open(*args, &block)
-    backend.open(*args, &block)
+  def open(*args, **options, &block)
+    backend.open(*args, **options, &block)
   end
 
   # Allows setting a backend via a symbol or a downloader object.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: down
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.4.0
 platform: ruby
 authors:
 - Janko Marohnić
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-09-26 00:00:00.000000000 Z
+date: 2022-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '2.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '2.8'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -66,20 +66,40 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: httpx
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.22.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.22.2
 - !ruby/object:Gem::Dependency
   name: http
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: posix-spawn
   requirement: !ruby/object:Gem::Requirement
@@ -109,7 +129,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: docker-api
+  name: warning
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -122,7 +142,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - janko.marohnic@gmail.com
 executables: []
@@ -138,6 +158,7 @@ files:
 - lib/down/chunked_io.rb
 - lib/down/errors.rb
 - lib/down/http.rb
+- lib/down/httpx.rb
 - lib/down/net_http.rb
 - lib/down/utils.rb
 - lib/down/version.rb
@@ -146,7 +167,7 @@ homepage: https://github.com/janko/down
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -154,15 +175,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.1'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.4.1
+signing_key:
 specification_version: 4
 summary: Robust streaming downloads using Net::HTTP, HTTP.rb or wget.
 test_files: []