http_zip 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c5c21ac606a405c8527ce48a94f760ecd195104a4ac84a25c84bbb095a748c21
+  data.tar.gz: 3b9c5d83fcbbbf09b858411fe10f56fc582738914bfbd5b54626571705eff72c
+SHA512:
+  metadata.gz: 6770e900fbf8a657716f0426e394646ba1bcd796cce64317c9d34996bd792847d1cd147ac0c7a49a64641787519a15c4d2abcc8933f01379e75f9607359049c2
+  data.tar.gz: 1d85ea79fd3e03302e242c4fce86a4fdf45ead85e663f3a5b4b91cf5cb735081a5d50aecd2e7931de6ef7b1064dcc6d174c2b25222689cee24ba7d26cbe8c2e9

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.9
+before_install: gem install bundler -v 2.0.2

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in http_zip.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Marvin Killing, Peter Retzlaff
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+# HttpZip
+
+HttpZip is a Ruby gem to extract individual files from a remote ZIP archive, without the need to download the entire file.
+
+If your Zip file is hosted on a server that supports Content-Range requests and you only want to extract individual files, you don't need to download
+the entire archive to do that. HttpZip uses Content-Range requests to first read only the Central Directory of your archive and builds a list of entries
+from that. You can then download and extract individual entries without downloading the entire archive.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'http_zip'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install http_zip
+
+## Usage
+
+```ruby
+# Create a new HttpZip::File referencing your remote archive.
+# This only makes a HEAD request to check the server for
+# Range request support.
+zip = HttpZip::File.new("https://www.example.org/archive.zip")
+
+# Get a reference to a specific file.
+# This only requests the archive's Central Directory Entry.
+entry = zip.entries.find { |e| e.name == 'compressed.txt' }
+
+# Read the extracted file contents into memory.
+# This downloads the entry's compressed contents and uncompresses
+# them locally.
+content = entry.read
+# You can also write the extracted entry directly to a local file.
+entry.write_to_file('/path/extracted.txt')
+```
+
+If the server that the zip file is hosted on doesn't support Range requests, HttpZip will throw `HttpZip::ContentRangeError`. If you want you can check this beforehand by calling:
+
+```ruby
+HttpZip::RangeRequest.server_supports_content_range?(url)
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/peret/http_zip.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'http_zip'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/http_zip.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'http_zip/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'http_zip'
+  spec.version       = HttpZip::VERSION
+  spec.authors       = ['Marvin Killing', 'Peter Retzlaff']
+  spec.email         = ['pe.retzlaff@gmail.com']
+
+  spec.summary       = 'HttpZip is a gem to extract individual files from a remote ZIP archive, without the need to download the entire file.'
+  spec.homepage      = 'https://github.com/peret/http_zip'
+  spec.license       = 'MIT'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/peret/http_zip'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'httparty', '~> 0.20'
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'minitest', '~> 5.15'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'simplecov', '~> 0.21'
+  spec.add_development_dependency 'webmock', '~> 3.14'
+end

data/lib/http_zip/entry.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module HttpZip
+  # Describes one entry in an HTTP zip archive
+  # @attr_reader [String] name filename of the entry
+  class Entry
+    attr_reader :name
+
+    def initialize(url, name, header_offset, central_directory_file_compressed_size)
+      @range_request = HttpZip::RangeRequest.new(url)
+      @name = name
+      @header_offset = header_offset
+      @compressed_size = central_directory_file_compressed_size
+    end
+
+    # Get the decompressed content of the file entry
+    # Makes 2 HTTP requests (GET, GET)
+    def read
+      # decompress the file
+      from = @header_offset + header_size
+      to = @header_offset + header_size + @compressed_size
+
+      decompress, _finish = decompress_funcs
+
+      compressed_contents = @range_request.get(from, to)
+      decompress.call(compressed_contents)
+    end
+
+    # Get the decompressed content of the file entry
+    # Makes 2 HTTP requests (GET, GET)
+    def write_to_file(filename)
+      from = @header_offset + header_size
+      to = @header_offset + header_size + @compressed_size
+
+      decompress, finish = decompress_funcs
+
+      ::File.open(filename, 'wb') do |out_file|
+        @range_request.get(from, to) do |chunk|
+          decompressed = decompress.call(chunk)
+          out_file.write(decompressed)
+        end
+        finish.call
+      end
+    end
+
+    private
+
+    def header
+      @header ||= @range_request.get(@header_offset, @header_offset + 30)
+      @header
+    end
+
+    def header_size
+      # find out where the file contents start and how large the file is
+      file_name_length = header[26...28].unpack1('v')
+      extra_field_length = header[28...30].unpack1('v')
+      30 + file_name_length + extra_field_length
+    end
+
+    def decompress_funcs
+      # which compression method is used?
+      compression_method = header[8...10].unpack1('v')
+
+      case compression_method
+      when 0
+        # STORED content, doesn't require decompression
+        decompress = lambda { |input|
+          input
+        }
+        finish = -> {}
+      when 8
+        inflater = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+        # DEFLATED content, inflate it
+        decompress = lambda { |input|
+          inflater.inflate(input)
+        }
+        finish = lambda do
+          inflater.finish
+          inflater.close
+        end
+      else
+        raise HttpZip::ZipError,
+              "Unsupported compression method #{compression_method}. HttpZip only supports compression methods 0 (STORED) and 8 (DEFLATE)."
+      end
+
+      [decompress, finish]
+    end
+  end
+end

data/lib/http_zip/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module HttpZip
+  class Error < StandardError; end
+  class ContentRangeError < Error; end
+  class ZipError < Error; end
+end

data/lib/http_zip/file.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module HttpZip
+  # 256x256 bytes is the maximum length of the EOCD comment,
+  # 22 bytes is the remaining EOCD size
+  # 20 bytes is the EOCD64 locator size
+  MAXIMUM_EOCD_AND_EOCD64_LOCATOR_SIZE = (256 * 256) + 22 + 20
+  EOCD64_SIZE_WITHOUT_COMMENT = 56
+
+  # HttpZip reads ZIP-files over a HTTP connection that supports the Content-Range header.
+  # It is a helpful tool to extract single files from large HTTP archives without having to
+  # download them fully.
+  #
+  # Resources regarding the ZIP file format:
+  # https://en.wikipedia.org/wiki/ZIP_(file_format)
+  # https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+  class File
+    # Create a HttpZip file object that is located at url.
+    #
+    # @param [String] url where the file is hosted
+    # @raise [ContentRangeError] if the server does not support the Range header
+    def initialize(url)
+      @url = url
+      @entries = nil
+      @range_request = RangeRequest.new(url)
+      @range_request.check_server_supports_content_range!
+    end
+
+    # Get all entries in the zip archive as an array of HttpZip::Entry.
+    # Makes up to 4 HTTP requests (HEAD, GET, GET, GET?)
+    def entries
+      return @entries if @entries
+
+      @entries = []
+      last_bytes_of_file = @range_request.last(MAXIMUM_EOCD_AND_EOCD64_LOCATOR_SIZE)
+      central_directory_bytes = get_central_directory(last_bytes_of_file)
+
+      # iterate through central directory and spit out file entries
+      until central_directory_bytes.empty?
+        # get information about the current file entry
+        file_header = HttpZip::Parser::CentralDirectoryFileHeader.new(central_directory_bytes)
+        @entries << HttpZip::Entry.new(
+          @url,
+          file_header.file_name,
+          file_header.header_offset,
+          file_header.compressed_size
+        )
+
+        # skip ahead to next file entry
+        central_directory_bytes = central_directory_bytes[(file_header.end_of_entry)..-1]
+      end
+
+      @entries
+    end
+
+    private
+
+    # The central directory contains all file names within the archive as well as
+    # their offsets to the beginning of the archive file.
+    # Get the whole central directory so the client can traverse it and find the
+    # file entry they are looking for.
+    #
+    # makes 1 GET request for non-Zip64 files, 2 GET requests for Zip64 files
+    def get_central_directory(last_bytes_of_file)
+      central_directory = HttpZip::Parser::CentralDirectory.new(last_bytes_of_file)
+      if central_directory.eocd64_offset
+        # This is a Zip64 archive, so parse the EOCD64 block to find out where the central directory
+        # is located
+        eocd64_block = @range_request.get(
+          central_directory.eocd64_offset,
+          central_directory.eocd64_offset + EOCD64_SIZE_WITHOUT_COMMENT
+        )
+        central_directory.parse_eocd64!(eocd64_block)
+      end
+
+      # get the actual central directory
+      central_directory_end = central_directory.offset + central_directory.size
+      @range_request.get(central_directory.offset, central_directory_end)
+    end
+  end
+end

data/lib/http_zip/parser/central_directory.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module HttpZip
+  module Parser
+    # Parses the End Of Central Directory (EOCD) block of a zip file.
+    class CentralDirectory
+      EOCD_BLOCK_IDENTIFIER = "\x50\x4B\x05\x06"
+      EOCD64_LOCATOR_BLOCK_IDENTIFER = "\x50\x4b\x06\x07"
+      EOCD64_BLOCK_IDENTIFER = "\x50\x4b\x06\x06"
+
+      attr_reader :size, :offset, :eocd64_offset
+
+      # Create a new instance of CentralDirectory.
+      #
+      # @param [String] end_of_central_directory_bytes the byte string including the EOCD block
+      def initialize(end_of_central_directory_bytes)
+        @bytes = end_of_central_directory_bytes
+
+        parse!
+      end
+
+      # Read the size and offset of the central directory from a Zip64 EOCD block.
+      #
+      # @param [String] eocd64_block the byte string including the EOCD block for a zip64 archive
+      # @raise [ZipError] if the byte stream does not contain a valid EOCD64 block
+      def parse_eocd64!(eocd64_block)
+        unless eocd64_block.start_with?(EOCD64_BLOCK_IDENTIFER)
+          raise ZipError, 'EOCD64 record not found'
+        end
+
+        @size, @offset = eocd64_block[40..-1].unpack('Q<Q<')
+      end
+
+      private
+
+      # Parses the size and offset of the central directory from the EOCD block.
+      # If this is a zip64 archive, the `eocd64_offset` will be set.
+      # @raise [ZipError] if this is a zip64 archive and the EOCD64 locator block is not found or
+      #   the archive is split on multipe disks.
+      def parse!
+        eocd_block_index = get_eocd_block_index(@bytes)
+        eocd_block = @bytes[eocd_block_index..-1]
+        @size, @offset = eocd_block[12...20].unpack('VV')
+        return if @size != 0xFFFFFFFF && @offset != 0xFFFFFFFF
+
+        # there will be a zip64 EOCD locator block before the EOCD block
+        # parse the EOCD locator to find out where the EOCD64 block starts
+        eocd64_locator_block = @bytes[(eocd_block_index - 20)..eocd_block_index]
+        unless eocd64_locator_block.start_with?(EOCD64_LOCATOR_BLOCK_IDENTIFER)
+          raise ZipError, 'Could not locate the EOCD64 locator block'
+        end
+
+        @eocd64_offset, total_num_disks = eocd64_locator_block[8..-1].unpack('Q<V')
+        return if total_num_disks == 1
+
+        raise ZipError, 'Multi-disk archives are not supported'
+      end
+
+      # In order to find the central directory, we have to first find the EOCD block.
+      # The EOCD block (End Of Central Directory) identifies the end of the central directory
+      # of the zip file and contains the offset where the central directory is located and its length.
+      # The EOCD block is always at the end of the file.
+      def get_eocd_block_index(last_bytes_of_file)
+        # From the end of the file, get the maximum amount of bytes the EOCD block can have
+        candidate_eocd_block = last_bytes_of_file
+
+        # Scan the downloaded bytes from right to left to find the magic EOCD
+        # block identifier
+        eocd_block_start_index = nil
+        search_end_position = candidate_eocd_block.length
+        loop do
+          eocd_block_start_index = candidate_eocd_block.rindex(EOCD_BLOCK_IDENTIFIER,
+                                                               search_end_position)
+
+          raise ZipError, 'Could not locate valid EOCD block' if eocd_block_start_index.nil?
+
+          # we have a candidate, verify that we found the actual eocd block start by
+          # checking whether its position + length matches the end of the file
+          comment_length = candidate_eocd_block[(eocd_block_start_index + 20)...(eocd_block_start_index + 22)].unpack1('v')
+          if (eocd_block_start_index + 22 + comment_length) == candidate_eocd_block.length
+            # we found it
+            break
+          end
+
+          search_end_position = eocd_block_start_index
+        end
+
+        eocd_block_start_index
+      end
+    end
+  end
+end

data/lib/http_zip/parser/central_directory_file_header.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module HttpZip
+  module Parser
+    # Parses the Central Directory File Header.
+    class CentralDirectoryFileHeader
+      ZIP64_EXTRA_FIELD_HEADER_ID = "\x01\x00"
+      CENTRAL_DIRECTORY_FILE_HEADER_IDENTIFIER = "\x50\x4B\x01\x02"
+
+      attr_reader(
+        :compressed_size,
+        :uncompressed_size,
+        :file_name_length,
+        :extra_field_length,
+        :file_comment_length,
+        :disk_number,
+        :internal_file_attributes,
+        :external_file_attributes,
+        :header_offset,
+        :file_name,
+        :end_of_entry
+      )
+
+      # Create a new instance of CentralDirectoryFileHeader.
+      #
+      # @param [String] file_header_bytes the byte string of the file header
+      # @raises [ZipError] if byte string doesn't not represent a valid file header
+      def initialize(file_header_bytes)
+        @bytes = file_header_bytes
+        unless @bytes.start_with?(CENTRAL_DIRECTORY_FILE_HEADER_IDENTIFIER)
+          raise ZipError, 'Central Directory File Header seems to be corrupt'
+        end
+
+        parse!
+      end
+
+      private
+
+      # Parses the fields from the Central Directory File Header,
+      # including data in Zip64 extra fields
+      def parse!
+        @compressed_size,
+          @uncompressed_size,
+          @file_name_length,
+          @extra_field_length,
+          @file_comment_length,
+          @disk_number,
+          @internal_file_attributes,
+          @external_file_attributes,
+          @header_offset = @bytes[20...46].unpack('VVvvvvvVV')
+
+        file_name_end = 46 + file_name_length
+        @file_name = @bytes[46...file_name_end]
+        @end_of_entry = file_name_end + @extra_field_length + @file_comment_length
+
+        # check if any of the values could not be represented by standard zip and will be stored in a
+        # Zip64 extra field
+        extra_field_bytes = @bytes[file_name_end...(file_name_end + @extra_field_length)]
+        parse_zip64_extra_field_if_present!(extra_field_bytes)
+      end
+
+      # Parses the extra fields section of a Central Directory File Header in order to extract
+      # the larger values for uncompressed size, compressed size, header offset, and disk number
+      # of the ZIP file if they weren’t specified in the Central Directory File Header already.
+      #
+      # @param [String] full_extra_field_bytes the byte stream of the full extra fields
+      #                 section of this Central Directory File Header
+      def parse_zip64_extra_field_if_present!(full_extra_field_bytes)
+        remaining_extra_field_bytes = full_extra_field_bytes
+        until remaining_extra_field_bytes.empty?
+          # zipalign might fill up the extra fields with all zero characters,
+          # so we need to abort if there’s nothing of value in the extra fields
+          break if remaining_extra_field_bytes.delete("\0").empty?
+
+          record_length = remaining_extra_field_bytes[2...4].unpack1('v')
+
+          # did we find the Zip64 extra field?
+          if remaining_extra_field_bytes.start_with?(ZIP64_EXTRA_FIELD_HEADER_ID)
+            read_values_from_extra_field_bytes!(remaining_extra_field_bytes[2..-1])
+            break
+          end
+
+          total_extra_field_length = 2 + 2 + record_length
+          remaining_extra_field_bytes = remaining_extra_field_bytes[total_extra_field_length..-1]
+        end
+      end
+
+      # Sets values for uncompressed size, compressed size, header offset, and disk number
+      # according to the values stored in the extra field.
+      #
+      # @param [String] extra_field_bytes the byte stream of the extra fields, starting right after
+      #   the extra field header identifier
+      def read_values_from_extra_field_bytes!(extra_field_bytes)
+        # the zip64 extra field tries to store as little information as possible,
+        # so only the values too large for the non-zip64 file header will be stored here
+        ptr = 2 # ignore the size field, since it seems to be incorrect in some cases
+        if @uncompressed_size == 0xFFFFFFFF
+          @uncompressed_size = extra_field_bytes[ptr...(ptr + 8)].unpack1('Q<')
+          ptr += 8
+        end
+        if @compressed_size == 0xFFFFFFFF
+          @compressed_size = extra_field_bytes[ptr...(ptr + 8)].unpack1('Q<')
+          ptr += 8
+        end
+        if @header_offset == 0xFFFFFFFF
+          @header_offset = extra_field_bytes[ptr...(ptr + 8)].unpack1('Q<')
+          ptr += 8
+        end
+        if @disk_number == 0xFFFF
+          @disk_number = extra_field_bytes[ptr...(ptr + 4)].unpack1('V')
+        end
+      end
+    end
+  end
+end

data/lib/http_zip/range_request.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'httparty'
+
+module HttpZip
+  # Class to make Range requests to a HTTP server
+  class RangeRequest
+    # Create a new RangeRequest object
+    #
+    # @param [String] url remote file URL
+    def initialize(url)
+      @url = url
+    end
+
+    # Request a partial object via HTTP. If a block is given, yields the response body in chunks.
+    #
+    # @param [Integer] from start byte of the range to request. Inclusive.
+    # @param [Integer] to end byte of the range to request. Exclusive.
+    # @yield [chunk] yields a chunk of data to the block
+    # @raise [ContentRangeError] if the server responds with anything other than 206 Partial Content
+    def get(from, to)
+      options = { headers: { 'Range' => "bytes=#{from}-#{to - 1}" } }
+      options[:stream_body] = true if block_given?
+
+      response = HTTParty.get(@url, options) do |chunk|
+        yield chunk if block_given?
+      end
+
+      if response.code != 206
+        # oops, we downloaded the whole file
+        raise ContentRangeError, 'Server does not support the Range header'
+      end
+
+      response.body
+    end
+
+    # Request the last `num_bytes` bytes of the remote file via HTTP.
+    #
+    # @param [Integer] num_bytes number of bytes to request
+    # @raise [ContentRangeError] if the server responds with anything other than 206 Partial Content
+    def last(num_bytes)
+      response = HTTParty.get(@url, headers: { 'Range' => "bytes=-#{num_bytes}" })
+      if response.code != 206
+        # oops, we downloaded the whole file
+        raise ContentRangeError, 'Server does not support the Range header'
+      end
+
+      response.body
+    end
+
+    # Tests if the server supports the Range header by checking the "Accept-Ranges" header,
+    # otherwise raises an exception.
+    #
+    # @raise [ContentRangeError] if the server does not support the Range header
+    def check_server_supports_content_range!
+      return if self.class.server_supports_content_range?(@url)
+
+      raise ContentRangeError, 'Server does not support the Range header'
+    end
+
+    # Tests if the server supports the Range header by checking the "Accept-Ranges" header.
+    #
+    # @param [String] url remote file URL
+    # @return [Boolean] true if the server supports the Range header
+    def self.server_supports_content_range?(url)
+      response = HTTParty.head(url)
+      response.headers['Accept-Ranges'] && response.headers['Accept-Ranges'].downcase != 'none'
+    end
+  end
+end

data/lib/http_zip/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module HttpZip
+  VERSION = '1.0.0'
+end

data/lib/http_zip.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'http_zip/version'
+require 'http_zip/errors'
+require 'http_zip/range_request'
+require 'http_zip/entry'
+require 'http_zip/file'
+require 'http_zip/parser/central_directory_file_header'
+require 'http_zip/parser/central_directory'

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: http_zip
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Marvin Killing
+- Peter Retzlaff
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.14'
+description:
+email:
+- pe.retzlaff@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- http_zip.gemspec
+- lib/http_zip.rb
+- lib/http_zip/entry.rb
+- lib/http_zip/errors.rb
+- lib/http_zip/file.rb
+- lib/http_zip/parser/central_directory.rb
+- lib/http_zip/parser/central_directory_file_header.rb
+- lib/http_zip/range_request.rb
+- lib/http_zip/version.rb
+homepage: https://github.com/peret/http_zip
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/peret/http_zip
+  source_code_uri: https://github.com/peret/http_zip
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key:
+specification_version: 4
+summary: HttpZip is a gem to extract individual files from a remote ZIP archive, without
+  the need to download the entire file.
+test_files: []