gemkeeper 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79e1b77de1b2e65913e3e6c5c779ec2da40de77248d3f19023638f6bde8de52d
-  data.tar.gz: 3ab3353aeacb8a191b390130e15b69226e1f81955a88175183d25a21b0d150b3
+  metadata.gz: 88d9b763777c56c907c9c945fb35f7a782b6be529d7af8f38b5d14a899cda825
+  data.tar.gz: 201987b7a1d4307548b8d7f020fb25a2e7ecf274f85e37f5156a26065fde8fa4
 SHA512:
-  metadata.gz: 0a55f01e490978fbb972e095407a7f18ad915e0c9a35bfacd54e577a1a7285cf7703d5bca056ab5ce7fa4d792385ca64ddc842b93028d763879ec186b6bc86b0
-  data.tar.gz: 4318c10b34fb9a183bcd4d08f9a78b0295dc83bd7d90246a6711cf69a0c1c614cda600713f2e917b64de35024c159f7d3943f365c77639fc01126420afe13a47
+  metadata.gz: 79924f19d7da544373cdd0d213e818a1b4fc1411651bdc1819d331fb16a9361200e20a2de52b4319ebac064bf64bc14503abae89d8463e2d522e04d9f840c4d1
+  data.tar.gz: 3e175013111f44149a4c3273fb21fa1fe1785763713fd14eb698e33dcd9b898933a5e6a485d76c5fe0e23ef1f3ed5a4d8f92aff5fea85793e94dda4b1a7e3b9a

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+## [0.8.0] - 2026-05-29
+
+### Changed
+
+- Refactored `CompactIndexServer` into focused collaborators — `RubygemsClient`, `IndexMerger`, `GemCache`, `ResponseBuilder`, `UploadHandler`, `SpecMapper`, plus `Response` and `CacheMeta` value objects.
+  No behavior change; this splits the responsibilities that the initial single-file server bundled together and restores the rubycritic score above the 90 gate.
+- Renamed leftover "Geminabox" references to the Gemkeeper server, reflecting the compact index server that replaced it.
+  CLI output and `Configuration#server_url` (was `geminabox_url`) are updated; no behavior change.
+
+### Fixed
+
+- `gemkeeper server start` no longer fails with a `LoadError` when run from source.
+  The spawned `rackup` process does not inherit the executable's `$LOAD_PATH`, so it could not require `gemkeeper/compact_index_server`; the rackup command now passes the gem's `lib/` via `-I`.
+- `gemkeeper sync` now repopulates a fresh or repointed server instead of skipping every gem.
+  The skip decision was based on a local build artifact, which could diverge from the server's store; it now asks the server's private store directly (new read-only `GET /gemkeeper/has/<name>/<version>` endpoint) and re-uploads an existing artifact without rebuilding when the server is missing it.
+
 ## [0.7.2] - 2026-05-28
 
 ### Fixed
@@ -170,7 +186,8 @@
 
 - Initial release
 
-[Unreleased]: https://github.com/danhorst/gemkeeper/compare/v0.7.2...HEAD
+[Unreleased]: https://github.com/danhorst/gemkeeper/compare/v0.8.0...HEAD
+[0.8.0]: https://github.com/danhorst/gemkeeper/compare/0.7.2...0.8.0
 [0.7.2]: https://github.com/danhorst/gemkeeper/compare/0.7.1...0.7.2
 [0.7.1]: https://github.com/danhorst/gemkeeper/compare/0.7.0...0.7.1
 [0.7.0]: https://github.com/danhorst/gemkeeper/compare/0.6.7...0.7.0

data/README.md

@@ -1,6 +1,6 @@
 ![Gemkeeper](./img/gemkeeper.jpeg)
 
-This project is an opinionated wrapper around [Gem in a Box][1] for managing private gem dependencies in an offline development environment.
+This project manages private gem dependencies in an offline development environment, building internal gems from source and serving them through a local compact index server.
 
 ## Installation
 
@@ -17,14 +17,14 @@ brew tap danhorst/tap
 brew install danhorst/tap/gemkeeper
 ```
 
-Forumla: [`danhorst/homebrew-tap`][2]
+Forumla: [`danhorst/homebrew-tap`][1]
 
 ## Workstation Setup
 
 If you cannot reach your organization's private gem server, follow these steps to use gemkeeper as a local proxy.
 
 **Prerequisites:** You must have HTTPS access to the internal gem repositories on GitHub.
-Configure GitHub credentials before step 4 — see [GitHub authentication docs][3].
+Configure GitHub credentials before step 4 — see [GitHub authentication docs][2].
 
 1. Install gemkeeper:
 
@@ -65,12 +65,12 @@ bundle config set --local mirror.<your-private-gem-source-url> http://localhost:
 ```
 
 Replace `<your-private-gem-source-url>` with the gem source URL declared in your `Gemfile` (the one that requires VPN or private credentials).
-The mirror approach redirects gem resolution to your local Geminabox without modifying the committed `Gemfile` or `Gemfile.lock`.
+The mirror approach redirects gem resolution to your local Gemkeeper server without modifying the committed `Gemfile` or `Gemfile.lock`.
 Public gems are proxied from RubyGems.org automatically.
 
 ## Quick Start
 
-1. Ensure your org manifest is present at `~/.config/gemkeeper/manifest.yml` (see [Workstation Setup](#workstation-setup)), then create a project `gemkeeper.yml`:
+1. Ensure your org manifest is present at `~/.config/gemkeeper/manifest.yml` (see [Workstation Setup][3]), then create a project `gemkeeper.yml`:
 
 ```yaml
 port: 9292
@@ -115,7 +115,7 @@ Gemkeeper looks for configuration files in these locations (in order):
 ### Configuration Options
 
 ```yaml
-# Port for the Geminabox server (default: 9292)
+# Port for the Gemkeeper server (default: 9292)
 port: 9292
 
 # Where to clone gem repositories (default: ./cache/repos)
@@ -293,8 +293,8 @@ gemkeeper server stop
 
 1. **Clone/Pull**: Gemkeeper clones (or pulls) gem repositories to a local cache.
 2. **Build**: Builds `.gem` files from the source at the specified version/tag.
-3. **Upload**: Uploads built gems to a local Geminabox server.
-4. **Proxy**: Geminabox proxies public gems from RubyGems.org, so you only need one gem source.
+3. **Upload**: Uploads built gems to the local Gemkeeper server.
+4. **Proxy**: The server proxies public gems from RubyGems.org, so you only need one gem source.
 
 This lets you use a combination of public and private gems from a single gem source.
 
@@ -306,6 +306,6 @@ bundle exec rake test    # Run tests
 bundle exec rubocop      # Run linter
 ```
 
-[1]: https://github.com/geminabox/geminabox
-[2]: https://github.com/danhorst/homebrew-tap
-[3]: https://docs.github.com/en/authentication
+[1]: https://github.com/danhorst/homebrew-tap
+[2]: https://docs.github.com/en/authentication
+[3]: #workstation-setup

data/lib/gemkeeper/bundler_mirror_configurator.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Gemkeeper
-  # Configures Bundler mirror settings so private gem registries proxy through local Geminabox.
+  # Configures Bundler mirror settings so private gem registries proxy through the local Gemkeeper server.
   class BundlerMirrorConfigurator
     def initialize(candidates, port:, global:)
       @remotes = candidates.filter_map { |c| c[:remote] if c[:source_type] == :private_gem }.uniq

data/lib/gemkeeper/cli/commands/list.rb

@@ -4,7 +4,7 @@ module Gemkeeper
   module CLI
     module Commands
       class List < Dry::CLI::Command
-        desc "List gems cached in Geminabox"
+        desc "List gems cached locally"
 
         option :config, type: :string, desc: "Path to config file"
 
@@ -15,7 +15,7 @@ module Gemkeeper
           gem_files = Dir.glob(File.join(gems_path, "gems", "*.gem"))
 
           if gem_files.empty?
-            puts "No gems cached in Geminabox"
+            puts "No gems cached locally"
             puts "  Gems directory: #{gems_path}"
             return
           end

data/lib/gemkeeper/cli/commands/server/start.rb

@@ -5,7 +5,7 @@ module Gemkeeper
     module Commands
       module Server
         class Start < Dry::CLI::Command
-          desc "Start the Geminabox server"
+          desc "Start the Gemkeeper server"
 
           option :port, type: :integer, desc: "Port to run server on"
           option :config, type: :string, desc: "Path to config file"
@@ -18,15 +18,15 @@ module Gemkeeper
             config = override_port(config, port) if port
 
             manager = ServerManager.new(config)
-            url = config.geminabox_url
+            url = config.server_url
 
             if options[:foreground]
-              puts "Starting Geminabox server at #{url}"
+              puts "Starting Gemkeeper server at #{url}"
               puts "Press Ctrl+C to stop"
               manager.start_foreground
             else
               manager.start
-              puts "Geminabox server started at #{url}"
+              puts "Gemkeeper server started at #{url}"
               puts "PID: #{File.read(config.pid_file).strip}"
             end
           rescue ServerAlreadyRunningError => error

data/lib/gemkeeper/cli/commands/server/status.rb

@@ -5,7 +5,7 @@ module Gemkeeper
     module Commands
       module Server
         class Status < Dry::CLI::Command
-          desc "Check Geminabox server status"
+          desc "Check Gemkeeper server status"
 
           option :config, type: :string, desc: "Path to config file"
 
@@ -15,11 +15,11 @@ module Gemkeeper
             status = manager.status
 
             if status[:running]
-              puts "Geminabox server is running"
+              puts "Gemkeeper server is running"
               puts "  PID: #{status[:pid]}" if status[:pid]
               puts "  URL: #{status[:url]}"
             else
-              puts "Geminabox server is not running"
+              puts "Gemkeeper server is not running"
             end
           end
         end

data/lib/gemkeeper/cli/commands/server/stop.rb

@@ -5,7 +5,7 @@ module Gemkeeper
     module Commands
       module Server
         class Stop < Dry::CLI::Command
-          desc "Stop the Geminabox server"
+          desc "Stop the Gemkeeper server"
 
           option :config, type: :string, desc: "Path to config file"
 
@@ -14,9 +14,9 @@ module Gemkeeper
             manager = ServerManager.new(config)
             manager.stop
 
-            puts "Geminabox server stopped"
+            puts "Gemkeeper server stopped"
           rescue ServerNotRunningError
-            puts "Geminabox server is not running"
+            puts "Gemkeeper server is not running"
           rescue ServerError => error
             warn "Error stopping server: #{error.message}"
             exit 1

data/lib/gemkeeper/cli/commands/sync.rb

@@ -12,7 +12,7 @@ module Gemkeeper
         def call(gem_name: nil, **options)
           config = Configuration.load(options[:config])
           gems_to_sync = select_gems(config, gem_name)
-          syncer = GemSyncer.new(config, GemUploader.new(config.geminabox_url), manifest: ManifestReader.load)
+          syncer = GemSyncer.new(config, GemUploader.new(config.server_url), manifest: ManifestReader.load)
           counts, failures = run_sync(gems_to_sync, syncer)
           report_results(counts, failures, gems_to_sync.size)
         end

data/lib/gemkeeper/compact_index_server/cache_meta.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Gemkeeper
+  class CompactIndexServer
+    # The sidecar metadata for a cached upstream document: its ETag and when it
+    # was fetched. Knows whether it has aged past a TTL and how to serialize.
+    class CacheMeta
+      attr_reader :etag
+
+      def self.load(hash)
+        return nil unless hash
+
+        new(hash["etag"], hash["fetched_at"])
+      end
+
+      def initialize(etag, fetched_at)
+        @etag       = etag
+        @fetched_at = fetched_at
+      end
+
+      def expired?(ttl)
+        return true unless @fetched_at
+
+        Time.now - Time.parse(@fetched_at.to_s) > ttl
+      rescue ArgumentError
+        true
+      end
+
+      def to_h = { "etag" => @etag, "fetched_at" => @fetched_at }
+    end
+  end
+end

data/lib/gemkeeper/compact_index_server/cache_store.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "yaml"
+
+require_relative "cache_meta"
+
+module Gemkeeper
+  class CompactIndexServer
+    # Handles on-disk cache I/O: atomic writes, sidecar metadata, TTL checks.
+    # All paths are resolved relative to a base directory.
+    class CacheStore
+      ENTRIES = {
+        versions: "versions",
+        versions_merged: "versions.merged",
+        versions_meta: "versions.meta",
+        names: "names",
+        names_merged: "names.merged",
+        names_meta: "names.meta"
+      }.freeze
+
+      def initialize(base_dir)
+        @base_dir = base_dir
+        FileUtils.mkdir_p([base_dir, File.join(base_dir, "info"), File.join(base_dir, "gems")])
+      end
+
+      def path(key_or_filename)
+        filename = ENTRIES.fetch(key_or_filename, key_or_filename)
+        File.join(@base_dir, filename.to_s)
+      end
+
+      def read_meta(filename)
+        full_path = File.join(@base_dir, "#{filename}.meta")
+        return nil unless File.exist?(full_path)
+
+        CacheMeta.load(YAML.safe_load_file(full_path))
+      rescue StandardError
+        nil
+      end
+
+      def write_meta(filename, etag:)
+        meta = CacheMeta.new(etag, Time.now.utc.iso8601)
+        atomic_write(File.join(@base_dir, "#{filename}.meta"), meta.to_h.to_yaml)
+      end
+
+      def atomic_write(full_path, content)
+        tmp = "#{full_path}.tmp.#{Process.pid}.#{Thread.current.object_id}"
+        File.binwrite(tmp, content)
+        File.rename(tmp, full_path)
+      rescue StandardError
+        File.unlink(tmp) if tmp && File.exist?(tmp)
+        raise
+      end
+
+      def etag_for(key)
+        full_path = path(key)
+        return nil unless File.exist?(full_path)
+
+        Digest::SHA256.hexdigest(File.binread(full_path))
+      end
+    end
+  end
+end

data/lib/gemkeeper/compact_index_server/gem_cache.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "digest"
+require "rubygems"
+
+module Gemkeeper
+  class CompactIndexServer
+    # Per-gem caching of /info documents and .gem binaries from RubyGems.org.
+    # Serves from the local RubyGems cache, then the disk cache, then upstream.
+    class GemCache
+      INFO_TTL = 3600 # 60 minutes
+
+      def initialize(store, client)
+        @store  = store
+        @client = client
+      end
+
+      # Returns {body:, etag:} or nil (not found).
+      # Raises UpstreamUnavailableError when unreachable with no cache.
+      def info(gemname)
+        path = @store.path("info/#{gemname}")
+        meta = @store.read_meta("info/#{gemname}")
+        return cached_entry(path, meta) if fresh?(path, meta)
+
+        fetch_info(gemname, path, meta)
+      rescue UpstreamUnavailableError
+        raise unless File.exist?(path)
+
+        cached_entry(path, meta)
+      end
+
+      # Returns a local path to the gem binary, or nil (not found).
+      # Raises UpstreamUnavailableError when unreachable with no cached copy.
+      def binary(filename)
+        system_gem_path(filename) ||
+          disk_cache_path(filename) ||
+          fetch_binary(filename, @store.path("gems/#{filename}"))
+      end
+
+      private
+
+      def system_gem_path(filename)
+        Gem.path.each do |gem_path|
+          candidate = File.join(gem_path, "cache", filename)
+          return candidate if File.exist?(candidate)
+        end
+        nil
+      end
+
+      def disk_cache_path(filename)
+        path = @store.path("gems/#{filename}")
+        File.exist?(path) ? path : nil
+      end
+
+      def fetch_info(gemname, path, meta)
+        response = @client.get("/info/#{gemname}", meta&.etag)
+        return store_info(gemname, path, response) unless response.not_modified?
+
+        @store.write_meta("info/#{gemname}", etag: meta.etag)
+        cached_entry(path, meta)
+      end
+
+      def store_info(gemname, path, response)
+        return nil unless response.success?
+
+        body = response.body
+        etag = response.etag || Digest::SHA256.hexdigest(body)
+        @store.atomic_write(path, body)
+        @store.write_meta("info/#{gemname}", etag: etag)
+        { body: body, etag: etag }
+      end
+
+      def fetch_binary(filename, cache_path)
+        response = @client.get("/gems/#{filename}", nil)
+        return nil unless response.success?
+
+        @store.atomic_write(cache_path, response.body) && cache_path
+      end
+
+      def fresh?(path, meta) = File.exist?(path) && meta && !meta.expired?(INFO_TTL)
+
+      def cached_entry(path, meta)
+        body = File.binread(path)
+        { body:, etag: meta&.etag || Digest::SHA256.hexdigest(body) }
+      end
+    end
+  end
+end

data/lib/gemkeeper/compact_index_server/gem_index.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "compact_index"
+require "digest"
+require "fileutils"
+require "rubygems/package"
+
+require_relative "spec_mapper"
+
+module Gemkeeper
+  class CompactIndexServer
+    # Builds and maintains the in-memory index of privately-hosted gems.
+    # Scans gems_dir on construction and after each successful upload.
+    class GemIndex
+      def initialize(gems_dir)
+        @gems_dir = gems_dir
+        @gems     = {}
+        FileUtils.mkdir_p(@gems_dir)
+        rebuild
+      end
+
+      def [](name)   = @gems[name]
+      def keys       = @gems.keys
+      def values     = @gems.values
+
+      # True when the private store holds this exact name and bare-semver version.
+      def serves?(name, version)
+        gem = @gems[name]
+        gem ? gem.versions.any? { |gem_version| gem_version.number == version } : false
+      end
+
+      def gem_path(filename)
+        path = File.join(@gems_dir, filename)
+        File.exist?(path) ? path : nil
+      end
+
+      # Copies source_path into gems_dir, derives the filename from spec, and rebuilds.
+      # Raises Errno::EEXIST if the gem already exists. Returns the target filename.
+      def add(source_path, spec)
+        filename = SpecMapper.filename(spec)
+        target   = File.join(@gems_dir, filename)
+        raise Errno::EEXIST, target if File.exist?(target)
+
+        copy_into_place(source_path, target)
+        rebuild
+        filename
+      end
+
+      def rebuild
+        gems = {}
+        Dir.glob(File.join(@gems_dir, "*.gem")).each { |gem_file| index_gem(gems, gem_file) }
+        gems.each_value { |gem| stamp_checksum(gem) }
+        @gems = gems
+      end
+
+      private
+
+      def index_gem(gems, gem_file)
+        spec = Gem::Package.new(gem_file).spec
+        name = spec.name
+        (gems[name] ||= CompactIndex::Gem.new(name, [])).versions << SpecMapper.gem_version(spec, gem_file)
+      rescue StandardError => error
+        warn "gemkeeper: skipping #{File.basename(gem_file)}: #{error.message}"
+      end
+
+      def stamp_checksum(gem)
+        versions = gem.versions
+        versions.last.info_checksum = Digest::MD5.hexdigest(CompactIndex.info(versions))
+      end
+
+      def copy_into_place(source_path, target)
+        tmp = "#{target}.tmp.#{Process.pid}.#{Thread.current.object_id}"
+        FileUtils.cp(source_path, tmp)
+        File.rename(tmp, target)
+      end
+    end
+  end
+end

data/lib/gemkeeper/compact_index_server/index_merger.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "compact_index"
+require "digest"
+require "time"
+
+module Gemkeeper
+  class CompactIndexServer
+    # Generates the merged /versions and /names index files, combining upstream
+    # RubyGems.org data (refreshed on a TTL) with the locally-hosted private gems.
+    class IndexMerger
+      VERSIONS_TTL = 1800 # 30 minutes
+      NAMES_TTL    = 3600 # 60 minutes
+
+      def initialize(store, client)
+        @store         = store
+        @client        = client
+        @versions_etag = store.etag_for(:versions_merged)
+        @names_etag    = store.etag_for(:names_merged)
+      end
+
+      # Returns {path:, etag:} for the merged /versions file.
+      def versions(private_gems)
+        refresh(:versions, "/versions", VERSIONS_TTL)
+        regenerate_versions(private_gems)
+        { path: @store.path(:versions_merged), etag: @versions_etag }
+      end
+
+      # Returns {path:, etag:} for the merged /names file.
+      def names(private_names)
+        refresh(:names, "/names", NAMES_TTL)
+        regenerate_names(private_names)
+        { path: @store.path(:names_merged), etag: @names_etag }
+      end
+
+      private
+
+      def refresh(key, upstream_path, ttl)
+        meta = @store.read_meta(key.to_s)
+        return if meta && !meta.expired?(ttl) && File.exist?(@store.path(key))
+
+        apply(key, meta, @client.get(upstream_path, meta&.etag))
+      rescue UpstreamUnavailableError
+        nil # regeneration proceeds with whatever is cached
+      end
+
+      def apply(key, meta, response)
+        if response.not_modified?
+          etag = meta.etag
+        else
+          @store.atomic_write(@store.path(key), response.body)
+          etag = response.etag
+        end
+        @store.write_meta(key.to_s, etag: etag)
+      end
+
+      def regenerate_versions(private_gems)
+        versions_path = @store.path(:versions)
+        unless File.exist?(versions_path)
+          @store.atomic_write(versions_path, "created_at: #{Time.now.utc.iso8601}\n---\n")
+        end
+        merged = CompactIndex.versions(CompactIndex::VersionsFile.new(versions_path), private_gems)
+        @store.atomic_write(@store.path(:versions_merged), merged)
+        @versions_etag = Digest::SHA256.hexdigest(merged)
+      end
+
+      def regenerate_names(private_names)
+        merged = CompactIndex.names((upstream_names + private_names).uniq.sort)
+        @store.atomic_write(@store.path(:names_merged), merged)
+        @names_etag = Digest::SHA256.hexdigest(merged)
+      end
+
+      def upstream_names
+        names_path = @store.path(:names)
+        return [] unless File.exist?(names_path)
+
+        File.read(names_path).lines.map(&:strip).reject { |line| line.empty? || line == "---" }
+      end
+    end
+  end
+end

data/lib/gemkeeper/compact_index_server/response.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Gemkeeper
+  class CompactIndexServer
+    # Outcome of a compact-index request: a not-modified marker (304) or a
+    # body+etag (200), or a non-success status. Callers ask, never inspect.
+    Response = Struct.new(:status, :body, :etag) do
+      def not_modified? = status == 304
+      def success?      = status == 200
+    end
+  end
+end

data/lib/gemkeeper/compact_index_server/response_builder.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Gemkeeper
+  class CompactIndexServer
+    # Builds Rack responses for compact index payloads: conditional GET (ETag),
+    # byte-range requests, and the digest/accept-ranges headers Bundler expects.
+    class ResponseBuilder
+      def self.file(path)
+        [200,
+         { "content-type" => "application/octet-stream",
+           "content-length" => File.size(path).to_s },
+         File.open(path, "rb")]
+      end
+
+      def initialize(req)
+        @req = req
+      end
+
+      # 200 / 206 / 304 for an in-memory index body.
+      def index(body, etag)
+        quoted = %("#{etag}")
+        return [304, { "etag" => quoted }, []] if @req.env["HTTP_IF_NONE_MATCH"] == quoted
+
+        range(body, etag) || [200, index_headers(body, etag), [body]]
+      end
+
+      private
+
+      def range(body, etag)
+        header = @req.env["HTTP_RANGE"]
+        return nil unless header
+
+        size  = body.bytesize
+        match = header.match(/\Abytes=(\d+)-(\d*)\z/)
+        return unsatisfiable(size) unless match
+
+        start_byte = match[1].to_i
+        return unsatisfiable(size) if start_byte >= size
+
+        partial(body, etag, start_byte, match[2], size)
+      end
+
+      def partial(body, etag, start_byte, raw_end, size)
+        end_byte = raw_end.empty? ? size - 1 : [raw_end.to_i, size - 1].min
+        slice    = body.byteslice(start_byte, end_byte - start_byte + 1)
+        [206,
+         index_headers(body, etag).merge("content-range" => "bytes #{start_byte}-#{end_byte}/#{size}"),
+         [slice]]
+      end
+
+      def unsatisfiable(size) = [416, { "content-range" => "bytes */#{size}" }, []]
+
+      def index_headers(body, etag)
+        { "content-type" => "text/plain",
+          "etag" => %("#{etag}"),
+          "repr-digest" => "sha-256=:#{Digest::SHA256.base64digest(body)}:",
+          "accept-ranges" => "bytes" }
+      end
+    end
+  end
+end