down 3.2.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 813656418d3c378ea8a8731355e5b46f830cbb9e
-  data.tar.gz: 73e7e5125c7b4a2912672f63512fc822bddb552d
+  metadata.gz: 6d150dd7f5e9123d9c89ea2cc982fe154fb2345d
+  data.tar.gz: 3ecf281961282363ae6b9388c0d3d58cb901be76
 SHA512:
-  metadata.gz: f6a6427ffec868c38a689f0d992af7d6187234cfbdd9c63c94ebeb9192174880742eb58c2f7a7d4faed90c86b9a731a369dbadaa5fc37280cb8ef41b64dbeb90
-  data.tar.gz: 615d0c7c046727e07bc0e67b82906d7f5ca508fde7eb6b1f38b9ff6f3db787ab0eea4c055acc4584651a669aca38714a8a41f1320064e10c8ed0f559ebfce52f
+  metadata.gz: 93edf1ffb5f96ddc649a907bda723bcdcb82ab908ba8e1ca55cf9360e6cab79b4a8d3bc4957f6445bbce612ce857de7bd4486ccbd0b508455e5fb03899416d63
+  data.tar.gz: 13f2f52396e71eccc5e4f8cd9fcb6a2094ec10ac24beeff109745800d85bbee46fcf6c4f5b2b400836c299657d574a8fa86e72f45c32eb6adb7de6f6643495e8

data/README.md

@@ -1,8 +1,8 @@
 # Down
 
 Down is a utility tool for streaming, flexible and safe downloading of remote
-files. It can use [open-uri] + `Net::HTTP` or [HTTP.rb] as the backend HTTP
-library.
+files. It can use [open-uri] + `Net::HTTP`, [HTTP.rb] or `wget` as the backend
+HTTP library.
 
 ## Installation
 
@@ -27,8 +27,9 @@ The returned Tempfile has `#content_type` and `#original_filename` attributes
 determined from the response headers:
 
 ```rb
-tempfile.content_type      #=> "image/jpeg"
-tempfile.original_filename #=> "nature.jpg"
+tempfile.content_type      #=> "text/plain"
+tempfile.original_filename #=> "document.txt"
+tempfile.charset           #=> "utf-8"
 ```
 
 ### Maximum size
@@ -57,6 +58,19 @@ Down.download("http://user:password@example.org")
 Down.open("http://user:password@example.org")
 ```
 
+### Progress
+
+`Down.download` supports `:content_length_proc`, which gets called with the
+value of the `Content-Length` header as soon as it's received, and
+`:progress_proc`, which gets called with current filesize whenever a new chunk
+is downloaded.
+
+```rb
+Down.download "http://example.com/movie.mp4",
+  content_length_proc: -> (content_length) { ... },
+  progress_proc:       -> (progress)       { ... }
+```
+
 ## Streaming
 
 Down has the ability to retrieve content of the remote file *as it is being
@@ -180,24 +194,26 @@ the `Down::Error` subclasses. This is Down's exception hierarchy:
 
 By default Down implements `Down.download` and `Down.open` using the built-in
 [open-uri] + [Net::HTTP] Ruby standard libraries. However, there are other
-backends as well:
+backends as well, see the sections below.
+
+You can use the backend directly:
 
 ```rb
-require "down/net_http" # uses open-uri + Net::HTTP
-require "down/http"     # uses HTTP.rb gem
+require "down/net_http"
+
+Down::NetHttp.download("...")
+Down::NetHttp.open("...")
 ```
 
-When a backend is loaded, is overrides `Down.download` and `Down.open` methods,
-but it's recommended you always use the backends explicitly:
+Or you can set the backend globally (default is `:net_http`):
 
 ```rb
-# not recommended
+require "down"
+
+Down.backend :http # use the Down::Http backend
+
 Down.download("...")
 Down.open("...")
-
-# recommended
-Down::NetHttp.download("...")
-Down::NetHttp.open("...")
 ```
 
 ### open-uri + Net::HTTP
@@ -282,6 +298,15 @@ as request headers, like with open-uri.
 Down::NetHttp.open("http://example.com/image.jpg", {"Authorization" => "..."})
 ```
 
+You can also initialize the backend with default options:
+
+```rb
+net_http = Down::NetHttp.new(open_timeout: 3)
+
+net_http.download("http://example.com/image.jpg")
+net_http.open("http://example.com/image.jpg")
+```
+
 ### HTTP.rb
 
 ```rb
@@ -307,41 +332,77 @@ Net::HTTP include:
 * Chaninable HTTP client builder API for setting default options
 * Support for persistent connections
 
-### Default client
+#### Additional options
 
-You can change the default `HTTP::Client` to be used in all download requests
-via `Down::Http.client`:
+All additional options will be forwarded to `HTTP::Client#request`:
 
 ```rb
-# reuse Down's default client
-Down::Http.client = Down::Http.client.timeout(read: 3).feature(:auto_inflate)
-Down::Http.client.default_options.merge!(ssl_context: ctx)
+Down::Http.download("http://example.org/image.jpg", timeout: { open: 3 })
+Down::Http.open("http://example.org/image.jpg", follow: { max_hops: 0 })
+```
+
+If you prefer to add options using the chainable API, you can pass a block:
 
-# or set a new client
-Down::Http.client = HTTP.via("proxy-hostname.local", 8080)
+```rb
+Down::Http.open("http://example.org/image.jpg") do |client|
+  client.timeout(open: 3)
+end
 ```
 
-### Additional options
+You can also initialize the backend with default options:
+
+```rb
+http = Down::Http.new(timeout: { open: 3 })
+# or
+http = Down::Http.new(HTTP.timeout(open: 3))
+
+http.download("http://example.com/image.jpg")
+http.open("http://example.com/image.jpg")
+```
 
-All additional options passed to `Down::Download` and `Down.open` will be
-forwarded to `HTTP::Client#request`:
+### Wget (experimental)
 
 ```rb
-Down::Http.download("http://example.org/image.jpg", headers: {"Accept-Encoding" => "gzip"})
+gem "down", ">= 3.0"
+gem "posix-spawn" # omit if on JRuby
+gem "http_parser.rb"
 ```
+```rb
+require "down/wget"
 
-If you prefer to add options using the chainable API, you can pass a block:
+tempfile = Down::Wget.download("http://nature.com/forest.jpg")
+tempfile #=> #<Tempfile:/var/folders/k7/6zx6dx6x7ys3rv3srh0nyfj00000gn/T/20150925-55456-z7vxqz.jpg>
+
+io = Down::Wget.open("http://nature.com/forest.jpg")
+io #=> #<Down::ChunkedIO ...>
+```
+
+The Wget backend uses the `wget` command line utility for downloading. One
+major advantage of `wget` is that it automatically resumes downloads that were
+interrupted due to network failures, which is very useful when you're
+downloading large files.
+
+However, the Wget backend should still be considered experimental, as it wasn't
+easy to implement a CLI wrapper that streams output, so it's possible that I've
+made mistakes. Let me know how it's working out for you 😉.
+
+#### Additional arguments
+
+You can pass additional arguments to the underlying `wget` commmand via symbols:
 
 ```rb
-Down::Http.open("http://example.org/image.jpg") do |client|
-  client.timeout(read: 3)
-end
+Down::Wget.download("http://nature.com/forest.jpg", :no_proxy, connect_timeout: 3)
+Down::Wget.open("http://nature.com/forest.jpg", user: "janko", password: "secret")
 ```
 
-### Thread safety
+You can also initialize the backend with default arguments:
 
-`Down::Http.client` is stored in a thread-local variable, so using the HTTP.rb
-backend is thread safe.
+```rb
+wget = Down::Wget.new(:no_proxy, connect_timeout: 3)
+
+wget.download("http://nature.com/forest.jpg")
+wget.open("http://nature.com/forest.jpg")
+```
 
 ## Supported Ruby versions
 

data/down.gemspec

@@ -18,5 +18,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "minitest", "~> 5.8"
   spec.add_development_dependency "mocha"
   spec.add_development_dependency "http", "~> 2.1"
+  spec.add_development_dependency "posix-spawn" unless RUBY_ENGINE == "jruby"
+  spec.add_development_dependency "http_parser.rb"
   spec.add_development_dependency "docker-api"
 end

data/lib/down.rb

@@ -1,4 +1,31 @@
 # frozen-string-literal: true
 
 require "down/version"
-require "down/net_http" unless Down.respond_to?(:download)
+
+module Down
+  module_function
+
+  def download(*args, &block)
+    backend.download(*args, &block)
+  end
+
+  def open(*args, &block)
+    backend.open(*args, &block)
+  end
+
+  def backend(value = nil)
+    if value.is_a?(Symbol)
+      require "down/#{value}"
+      @backend = Down.const_get(value.to_s.split("_").map(&:capitalize).join)
+    elsif value
+      @backend = value
+    else
+      backend :net_http if @backend.nil?
+      @backend
+    end
+  end
+
+  def backend=(value)
+    @backend = value
+  end
+end

data/lib/down/backend.rb

@@ -0,0 +1,17 @@
+# frozen-string-literal: true
+
+require "down/version"
+require "down/chunked_io"
+require "down/errors"
+
+module Down
+  class Backend
+    def self.download(*args, &block)
+      new.download(*args, &block)
+    end
+
+    def self.open(*args, &block)
+      new.open(*args, &block)
+    end
+  end
+end

data/lib/down/chunked_io.rb

@@ -29,23 +29,52 @@ module Down
     def read(length = nil, outbuf = nil)
       raise IOError, "closed stream" if closed?
 
-      outbuf = outbuf.to_s.replace("").force_encoding(@encoding)
+      remaining_length = length
+
+      begin
+        data = readpartial(remaining_length, outbuf)
+        data = data.dup unless outbuf
+        remaining_length = length - data.bytesize if length
+      rescue EOFError
+      end
+
+      until remaining_length == 0 || eof?
+        data << readpartial(remaining_length)
+        remaining_length = length - data.bytesize if length
+      end
+
+      data.to_s unless length && (data.nil? || data.empty?)
+    end
+
+    def readpartial(length = nil, outbuf = nil)
+      raise IOError, "closed stream" if closed?
+
+      data = outbuf.replace("").force_encoding(@encoding) if outbuf
 
       if cache && !cache.eof?
-        cache.read(length, outbuf)
-        outbuf.force_encoding(@encoding)
+        data = cache.read(length, outbuf)
+        data.force_encoding(@encoding)
       end
 
-      until outbuf.bytesize == length || (@buffer.nil? && chunks_depleted?)
-        @buffer = retrieve_chunk if @buffer.nil?
+      if @buffer.nil? && (data.nil? || data.empty?)
+        raise EOFError, "end of file reached" if chunks_depleted?
+        @buffer = retrieve_chunk
+      end
+
+      remaining_length = data && length ? length - data.bytesize : length
 
-        buffered_data = if length && length - outbuf.bytesize < @buffer.bytesize
-                          @buffer.byteslice(0, length - outbuf.bytesize)
+      unless @buffer.nil? || remaining_length == 0
+        buffered_data = if remaining_length && remaining_length < @buffer.bytesize
+                          @buffer.byteslice(0, remaining_length)
                         else
                           @buffer
                         end
 
-        outbuf << buffered_data
+        if data
+          data << buffered_data
+        else
+          data = buffered_data
+        end
 
         cache.write(buffered_data) if cache
 
@@ -56,24 +85,7 @@ module Down
         end
       end
 
-      outbuf unless outbuf.empty? && length
-    end
-
-    def readpartial(maxlen = nil, outbuf = nil)
-      raise IOError, "closed stream" if closed?
-
-      available_length  = 0
-      available_length += cache.size - cache.pos if cache
-      available_length += @buffer.bytesize if @buffer
-
-      if available_length > 0
-        read([available_length, *maxlen].min, outbuf)
-      elsif !chunks_depleted?
-        read([@next_chunk.bytesize, *maxlen].min, outbuf)
-      else
-        outbuf.replace("").force_encoding(@encoding) if outbuf
-        raise EOFError, "end of file reached"
-      end
+      data
     end
 
     def eof?

data/lib/down/errors.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Down
   # generic error which is a superclass to all other errors
   class Error < StandardError; end
@@ -18,7 +20,7 @@ module Down
   class ResponseError < NotFound
     attr_reader :response
 
-    def initialize(message, response:)
+    def initialize(message, response: nil)
       super(message)
       @response = response
     end

data/lib/down/http.rb

@@ -2,9 +2,7 @@
 
 require "http"
 
-require "down/version"
-require "down/chunked_io"
-require "down/errors"
+require "down/backend"
 
 require "tempfile"
 require "cgi"
@@ -15,33 +13,31 @@ if Gem::Version.new(HTTP::VERSION) < Gem::Version.new("2.1.0")
 end
 
 module Down
-  module_function
+  class Http < Backend
+    def initialize(client_or_options = nil)
+      options = client_or_options
+      options = client_or_options.default_options if client_or_options.is_a?(HTTP::Client)
 
-  def download(url, **options, &block)
-    Http.download(url, **options, &block)
-  end
-
-  def open(url, **options, &block)
-    Http.open(url, **options, &block)
-  end
-
-  module Http
-    module_function
-
-    def download(url, **options, &block)
-      max_size = options.delete(:max_size)
+      @client = HTTP.headers("User-Agent" => "Down/#{VERSION}").follow(max_hops: 2)
+      @client = HTTP::Client.new(@client.default_options.merge(options)) if options
+    end
 
+    def download(url, max_size: nil, progress_proc: nil, content_length_proc: nil, **options, &block)
       io = open(url, **options, rewindable: false, &block)
 
+      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)"
       end
 
       extname  = File.extname(io.data[:response].uri.path)
-      tempfile = Tempfile.new(["down", extname], binmode: true)
+      tempfile = Tempfile.new(["down-http", extname], binmode: true)
 
-      io.each_chunk do |chunk|
-        tempfile.write(chunk)
+      until io.eof?
+        tempfile.write(io.readpartial)
+
+        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)"
@@ -75,11 +71,13 @@ module Down
         size:       response.content_length,
         encoding:   response.content_type.charset,
         rewindable: rewindable,
-        on_close:   (-> { response.connection.close } unless client.persistent?),
+        on_close:   (-> { response.connection.close } unless @client.persistent?),
         data:       { status: response.code, headers: response.headers.to_h, response: response },
       )
     end
 
+    private
+
     def get(url, **options, &block)
       uri = HTTP::URI.parse(url)
 
@@ -90,19 +88,11 @@ module Down
         uri.user = uri.password = nil
       end
 
-      client = self.client
+      client = @client
       client = block.call(client) if block
       client.get(url, options)
     end
 
-    def client
-      Thread.current[:down_client] ||= ::HTTP.headers("User-Agent" => "Down/#{VERSION}").follow(max_hops: 2)
-    end
-
-    def client=(value)
-      Thread.current[:down_client] = value
-    end
-
     def response_error!(response)
       args = [response.status.to_s, response: response]
 

data/lib/down/net_http.rb

@@ -1,33 +1,23 @@
+# frozen-string-literal: true
+
 require "open-uri"
 require "net/http"
 
-require "down/version"
-require "down/chunked_io"
-require "down/errors"
+require "down/backend"
 
 require "tempfile"
 require "fileutils"
 require "cgi"
 
 module Down
-  module_function
-
-  def download(uri, options = {})
-    NetHttp.download(uri, options)
-  end
-
-  def open(uri, options = {})
-    NetHttp.open(uri, options)
-  end
-
-  def copy_to_tempfile(basename, io)
-    NetHttp.copy_to_tempfile(basename, io)
-  end
-
-  module NetHttp
-    module_function
+  class NetHttp < Backend
+    def initialize(options = {})
+      @options = options
+    end
 
     def download(uri, options = {})
+      options = @options.merge(options)
+
       max_size            = options.delete(:max_size)
       max_redirects       = options.delete(:max_redirects) || 2
       progress_proc       = options.delete(:progress_proc)
@@ -65,7 +55,7 @@ module Down
         end
       end
 
-      open_uri_options.update(options)
+      open_uri_options.merge!(options)
 
       tries = max_redirects + 1
 
@@ -122,6 +112,8 @@ module Down
     end
 
     def open(uri, options = {})
+      options = @options.merge(options)
+
       begin
         uri = URI(uri)
         if uri.class != URI::HTTP && uri.class != URI::HTTPS
@@ -197,8 +189,10 @@ module Down
       )
     end
 
+    private
+
     def copy_to_tempfile(basename, io)
-      tempfile = Tempfile.new(["down", File.extname(basename)], binmode: true)
+      tempfile = Tempfile.new(["down-net_http", File.extname(basename)], binmode: true)
       if io.is_a?(OpenURI::Meta) && io.is_a?(Tempfile)
         io.close
         tempfile.close

data/lib/down/version.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Down
-  VERSION = "3.2.0"
+  VERSION = "4.0.0"
 end

data/lib/down/wget.rb

@@ -0,0 +1,229 @@
+# frozen-string-literal: true
+
+if RUBY_ENGINE == "jruby"
+  require "open3"
+else
+  require "posix-spawn"
+end
+require "http_parser"
+
+require "down/backend"
+
+require "tempfile"
+require "uri"
+require "cgi"
+
+module Down
+  class Wget < Backend
+    def initialize(*arguments)
+      @arguments = [max_redirect: 2, user_agent: "Down/#{VERSION}"] + arguments
+    end
+
+    def download(url, *args, max_size: nil, content_length_proc: nil, progress_proc: nil, **options)
+      io = open(url, **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)"
+      end
+
+      extname  = File.extname(URI(url).path)
+      tempfile = Tempfile.new(["down-wget", extname], binmode: true)
+
+      until io.eof?
+        tempfile.write(io.readpartial)
+
+        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)"
+        end
+      end
+
+      tempfile.open # flush written content
+
+      tempfile.extend DownloadedFile
+      tempfile.url     = url
+      tempfile.headers = io.data[:headers]
+
+      tempfile
+    rescue
+      tempfile.close! if tempfile
+      raise
+    ensure
+      io.close if io
+    end
+
+    def open(url, *args, rewindable: true, **options)
+      arguments = generate_command(url, *args, **options)
+
+      command = Command.execute(arguments)
+      output  = Down::ChunkedIO.new(
+        chunks:     command.enum_for(:output),
+        on_close:   command.method(:terminate),
+        rewindable: false,
+      )
+
+      # https://github.com/tmm1/http_parser.rb/issues/29#issuecomment-309976363
+      header_string  = output.readpartial
+      header_string << output.readpartial until header_string.include?("\r\n\r\n")
+      header_string, first_chunk = header_string.split("\r\n\r\n", 2)
+
+      parser = HTTP::Parser.new
+      parser << header_string
+
+      if parser.headers.nil?
+        output.close
+        raise Down::Error, "failed to parse response headers"
+      end
+
+      headers = parser.headers
+      status  = parser.status_code
+
+      content_length = headers["Content-Length"].to_i if headers["Content-Length"]
+      charset        = headers["Content-Type"][/;\s*charset=([^;]+)/i, 1] if headers["Content-Type"]
+
+      chunks = Enumerator.new do |yielder|
+        yielder << first_chunk if first_chunk
+        yielder << output.readpartial until output.eof?
+      end
+
+      Down::ChunkedIO.new(
+        chunks:     chunks,
+        size:       content_length,
+        encoding:   charset,
+        rewindable: rewindable,
+        on_close:   output.method(:close),
+        data:       { status: status, headers: headers },
+      )
+    end
+
+    private
+
+    def generate_command(url, *args, **options)
+      command = %W[wget --no-verbose --save-headers -O -]
+
+      options = @arguments.grep(Hash).inject({}, :merge).merge(options)
+      args    = @arguments.grep(Symbol) + args
+
+      (args + options.to_a).each do |option, value|
+        if option.length == 1
+          command << "-#{option}"
+        else
+          command << "--#{option.to_s.gsub("_", "-")}"
+        end
+
+        command << value.to_s unless value.nil?
+      end
+
+      command << url
+      command
+    end
+
+    class Command
+      PIPE_BUFFER_SIZE = 64*1024
+
+      def self.execute(arguments)
+        if RUBY_ENGINE == "jruby"
+          stdin_pipe, stdout_pipe, stderr_pipe, status_reaper = Open3.popen3(*arguments)
+        else
+          pid, stdin_pipe, stdout_pipe, stderr_pipe = POSIX::Spawn.popen4(*arguments)
+          status_reaper = Process.detach(pid)
+        end
+
+        stdin_pipe.close
+        [stdout_pipe, stderr_pipe].each(&:binmode)
+
+        new(stdout_pipe, stderr_pipe, status_reaper)
+      rescue Errno::ENOENT
+        raise Down::Error, "wget is not installed"
+      end
+
+      def initialize(stdout_pipe, stderr_pipe, status_reaper)
+        @status_reaper = status_reaper
+        @stdout_pipe   = stdout_pipe
+        @stderr_pipe   = stderr_pipe
+      end
+
+      def output
+        # Keep emptying the stderr buffer, to allow the subprocess to send more
+        # than 64KB if it wants to.
+        stderr_reader = Thread.new { @stderr_pipe.read }
+
+        yield @stdout_pipe.readpartial(PIPE_BUFFER_SIZE) until @stdout_pipe.eof?
+
+        status = @status_reaper.value
+        stderr = stderr_reader.value
+        close
+
+        case status.exitstatus
+        when 0  # No problems occurred
+          # success
+        when 1, # Generic error code
+             2, # Parse error---for instance, when parsing command-line options, the .wgetrc or .netrc...
+             3  # File I/O error
+          raise Down::Error, stderr
+        when 4  # Network failure
+          raise Down::TimeoutError, stderr if stderr.include?("timed out")
+          raise Down::ConnectionError, stderr
+        when 5  # SSL verification failure
+          raise Down::SSLError, stderr
+        when 6  # Username/password authentication failure
+          raise Down::ClientError, stderr
+        when 7  # Protocol errors
+          raise Down::Error, stderr
+        when 8  # Server issued an error response
+          raise Down::TooManyRedirects, stderr if stderr.include?("redirections exceeded")
+          raise Down::ResponseError, stderr
+        end
+      end
+
+      def terminate
+        begin
+          Process.kill("TERM", @status_reaper[:pid])
+        rescue Errno::ESRCH
+          # process has already terminated
+        end
+
+        close
+      end
+
+      def close
+        @stdout_pipe.close unless @stdout_pipe.closed?
+        @stderr_pipe.close unless @stderr_pipe.closed?
+      end
+    end
+
+    module DownloadedFile
+      attr_accessor :url, :headers
+
+      def original_filename
+        filename_from_content_disposition || filename_from_url
+      end
+
+      def content_type
+        headers["Content-Type"].to_s.split(";").first
+      end
+
+      def charset
+        headers["Content-Type"].to_s[/;\s*charset=([^;]+)/i, 1]
+      end
+
+      private
+
+      def filename_from_content_disposition
+        content_disposition = headers["Content-Disposition"].to_s
+        filename = content_disposition[/filename="([^"]*)"/, 1] || content_disposition[/filename=(.+)/, 1]
+        filename = CGI.unescape(filename.to_s.strip)
+        filename unless filename.empty?
+      end
+
+      def filename_from_url
+        path = URI(url).path
+        filename = path.split("/").last
+        CGI.unescape(filename) if filename
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: down
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Janko Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-21 00:00:00.000000000 Z
+date: 2017-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -52,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: posix-spawn
+  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: http_parser.rb
+  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: docker-api
   requirement: !ruby/object:Gem::Requirement
@@ -77,11 +105,13 @@ files:
 - README.md
 - down.gemspec
 - lib/down.rb
+- lib/down/backend.rb
 - lib/down/chunked_io.rb
 - lib/down/errors.rb
 - lib/down/http.rb
 - lib/down/net_http.rb
 - lib/down/version.rb
+- lib/down/wget.rb
 homepage: https://github.com/janko-m/down
 licenses:
 - MIT