gemvault 0.1.5 → 0.2.0

data/lib/gemvault/vault_path.rb

@@ -0,0 +1,33 @@
+require "uri"
+require "pathname"
+
+module Gemvault
+  ##
+  # Translates vault locators into filesystem paths.
+  #
+  # A locator is whatever a user hands the CLI or a package manager as "the
+  # vault": a plain filesystem path, a <tt>file://</tt> URI, or a
+  # <tt>vault://</tt> URI. Anything else passes through unchanged.
+  module VaultPath
+    SCHEMES = ["file", "vault"].freeze
+
+    module_function
+
+    # :call-seq:
+    #   resolve(locator) -> Pathname
+    #
+    # Resolves +locator+ to a Pathname. Two-slash relative forms such as
+    # <tt>file://vault.gemv</tt> parse their first segment as a URI host, so
+    # host and path are rejoined.
+    def resolve(locator)
+      begin
+        uri = URI.parse(locator.to_s)
+        return Pathname(locator.to_s) unless SCHEMES.include?(uri.scheme)
+
+        Pathname([uri.host, uri.path].compact.join)
+      rescue URI::InvalidURIError
+        Pathname(locator.to_s)
+      end
+    end
+  end
+end

data/lib/gemvault/vault_upgrade.rb

@@ -1,3 +1,4 @@
+require "pathname"
 require "fileutils"
 require_relative "vault"
 require_relative "deprecation"
@@ -7,20 +8,33 @@ module Gemvault
   # existing backend and rewriting it through the current-format writer, then
   # atomically swapping the file into place. Preserves each gem's created_at.
   class VaultUpgrade
+    include FileUtils
+
     # The from/to/gem-count summary of an upgrade; also detects an
     # already-current (no-op) vault.
-    Plan = Struct.new(:from_version, :to_version, :gem_count, keyword_init: true) do
-      def no_op?
-        from_version == to_version
+    class Plan < Data.define(:from_version, :to_version, :gem_count)
+      def no_op? = from_version == to_version
+
+      def to_s = "format #{from_version} -> #{to_version}"
+
+      def deconstruct_keys(_keys)
+        { from_version:, to_version:, gem_count:, no_op: no_op? }
       end
+    end
 
-      def to_s
-        "format #{from_version} -> #{to_version}"
+    # Copies gems from a source vault into a target vault, preserving each
+    # gem's stored timestamp. Holds the two endpoints so the per-gem call
+    # takes only the entry.
+    class GemCopy < Data.define(:source, :target)
+      def call(entry)
+        source.with_gem_file(entry) do |gem_path|
+          target.add(gem_path, created_at: entry.created_at)
+        end
       end
     end
 
     def initialize(path, backup: true)
-      @path = File.expand_path(path)
+      @path = Pathname(path).expand_path
       @backup = backup
     end
 
@@ -44,43 +58,36 @@ module Gemvault
     private
 
     def backup!
-      backup_path = "#{@path}.bak"
-      if File.exist?(backup_path)
-        raise Vault::Error, "Backup already exists: #{backup_path} (remove it or pass --no-backup)"
-      end
+      backup_path = Pathname("#{@path}.bak")
+      raise Vault::Error, "Backup already exists: #{backup_path} (remove it or pass --no-backup)" if backup_path.exist?
 
-      FileUtils.cp(@path, backup_path)
+      cp(@path, backup_path)
     end
 
     def rebuild(expected_count)
-      tmp = "#{@path}.upgrading"
-      FileUtils.rm_f(tmp)
+      tmp = Pathname("#{@path}.upgrading")
+      rm_f(tmp)
       copy_current_format(tmp)
-      verify_count!(tmp, expected_count)
-      File.rename(tmp, @path)
+      verify_count!(tmp:, expected_count:)
+      tmp.rename(@path)
     end
 
     def copy_current_format(tmp)
       Deprecation.silence do
         Vault.open(@path) do |old|
           target = Vault.new(tmp, create: true)
-          old.gem_entries.each { |entry| copy_gem(old, target, entry) }
+          copy = GemCopy.new(source: old, target:)
+          old.gem_entries.each { |entry| copy.call(entry) }
           target.close
         end
       end
     end
 
-    def copy_gem(old, target, entry)
-      old.with_gem_file(entry.name, entry.version, platform: entry.platform) do |gem_path|
-        target.add(gem_path, created_at: entry.created_at)
-      end
-    end
-
-    def verify_count!(tmp, expected_count)
+    def verify_count!(tmp:, expected_count:)
       actual = Vault.open(tmp, &:size)
       return if actual == expected_count
 
-      FileUtils.rm_f(tmp)
+      rm_f(tmp)
       raise Vault::Error, "Upgrade verification failed: expected #{expected_count} gems, got #{actual}"
     end
   end

data/lib/gemvault/version.rb

@@ -1,3 +1,3 @@
 module Gemvault
-  VERSION = "0.1.5".freeze
+  VERSION = "0.2.0".freeze
 end

data/lib/gemvault.rb

@@ -1,6 +1,7 @@
 require_relative "gemvault/version"
 require_relative "gemvault/deprecation"
 require_relative "gemvault/vault"
+require_relative "gemvault/vault_path"
 
 ##
 # Top-level namespace for the gemvault gem.

data/lib/rubygems/resolver/vault_set.rb

@@ -11,7 +11,7 @@ class Gem::Resolver::VaultSet < Gem::Resolver::Set
   end
 
   def find_all(req)
-    @specs.filter_map { |tuple| index_spec_for(req, tuple) }
+    @specs.filter_map { |candidate| index_spec_for(candidate) if req.match?(candidate) }
   end
 
   def prefetch(reqs); end
@@ -22,19 +22,17 @@ class Gem::Resolver::VaultSet < Gem::Resolver::Set
 
       pp.breakable
 
-      pp.seplist @specs do |tuple|
-        pp.text tuple.full_name
+      pp.seplist @specs do |candidate|
+        pp.text candidate.full_name
       end
     end
   end
 
   private
 
-  def index_spec_for(req, tuple)
-    return unless req.match?(tuple)
-
+  def index_spec_for(candidate)
     Gem::Resolver::IndexSpecification.new(
-      self, tuple.name, tuple.version, @source, tuple.platform
+      self, candidate.name, candidate.version, @source, candidate.platform
     )
   end
 end

data/lib/rubygems/source/vault.rb

@@ -1,8 +1,11 @@
 require "gemvault/vault"
-require "uri"
+require "gemvault/vault_path"
+require "gemvault/gem_entry"
+require "pathname"
 
 ##
-# A source backed by a .gemv vault file (SQLite archive of .gem blobs).
+# A source backed by a .gemv vault file: a tar archive of .gem files indexed
+# by a manifest. Legacy SQLite vaults are read transparently.
 #
 # Used by the gemvault RubyGems plugin to support:
 #
@@ -10,12 +13,11 @@ require "uri"
 class Gem::Source::Vault < Gem::Source
   include Gem::UserInteraction
 
-  VAULT_URI_SCHEMES = %w[file vault].freeze
-
   attr_reader :path
 
   def initialize(path)
-    @path = File.expand_path(filesystem_path(path))
+    resolved = Gemvault::VaultPath.resolve(path)
+    @path = Pathname(resolved).expand_path.to_s
     super(@path)
     @uri = @path
     @specs = nil
@@ -24,7 +26,7 @@ class Gem::Source::Vault < Gem::Source
   def load_specs(type)
     verbose "Loading #{type} specs from vault at #{@path}"
     ensure_specs_loaded
-    select_tuples(type)
+    select_candidates(type)
   end
 
   def fetch_spec(name_tuple)
@@ -38,17 +40,15 @@ class Gem::Source::Vault < Gem::Source
 
   def download(spec, dir = Dir.pwd)
     verbose "Extracting #{spec.file_name} from vault at #{@path}"
-    cache_dir = File.join(dir, "cache")
-    FileUtils.mkdir_p(cache_dir)
-
-    dest = File.join(cache_dir, spec.file_name)
+    dest = Pathname(dir).join("cache").tap(&:mkpath).join(spec.file_name)
 
     Gemvault::Vault.open(@path) do |vault|
-      data = vault.gem_data(spec.name, spec.version.to_s, platform: spec.platform.to_s)
-      File.binwrite(dest, data)
+      entry = entry_for(spec)
+      bytes = vault.gem_data(entry)
+      dest.binwrite(bytes)
     end
 
-    dest
+    dest.to_s
   end
 
   def dependency_resolver_set(prerelease = nil)
@@ -91,35 +91,32 @@ class Gem::Source::Vault < Gem::Source
 
   private
 
-  def filesystem_path(path)
-    uri = URI.parse(path.to_s)
-    VAULT_URI_SCHEMES.include?(uri.scheme) ? uri.path : path.to_s
-  rescue URI::InvalidURIError
-    path.to_s
+  def entry_for(spec)
+    Gemvault::GemEntry.from_spec(spec)
   end
 
-  def select_tuples(type)
+  def select_candidates(type)
     case type
-    when :released then released_tuples
-    when :prerelease then prerelease_tuples
-    when :latest then latest_tuples
+    when :released then released_candidates
+    when :prerelease then prerelease_candidates
+    when :latest then latest_candidates
     else @specs.keys
     end
   end
 
-  def released_tuples
-    @specs.keys.reject { |tuple| tuple.version.prerelease? }
+  def released_candidates
+    @specs.keys.reject { |candidate| candidate.version.prerelease? }
   end
 
-  def prerelease_tuples
-    @specs.keys.select { |tuple| tuple.version.prerelease? }
+  def prerelease_candidates
+    @specs.keys.select { |candidate| candidate.version.prerelease? }
   end
 
-  def latest_tuples
+  def latest_candidates
     @specs.keys
-          .group_by { |tuple| [tuple.name, tuple.platform] }
+          .group_by { |candidate| [candidate.name, candidate.platform] }
           .values
-          .map { |tuples| tuples.max_by(&:version) }
+          .map { |versions| versions.max_by(&:version) }
   end
 
   def ensure_specs_loaded
@@ -128,9 +125,8 @@ class Gem::Source::Vault < Gem::Source
     @specs = {}
     Gemvault::Vault.open(@path) do |vault|
       vault.gem_entries.each do |entry|
-        spec = vault.spec_from_blob(entry.name, entry.version, entry.platform)
-        tuple = spec.name_tuple
-        @specs[tuple] = spec
+        spec = vault.spec_from_blob(entry)
+        @specs[spec.name_tuple] = spec
       end
     end
   end

data/lib/rubygems_plugin.rb

@@ -31,8 +31,7 @@ module Gemvault
       Gem::OptionParser.accept Gem::URI::HTTP do |value|
         next value if value.to_s.end_with?(".gemv")
 
-        uri = parse_uri(value)
-        validate_scheme!(uri, value)
+        validate_uri!(value)
         value
       end
     end
@@ -40,12 +39,15 @@ module Gemvault
     private
 
     def parse_uri(value)
-      Gem::URI.parse value
-    rescue Gem::URI::InvalidURIError
-      raise Gem::OptionParser::InvalidArgument, value
+      begin
+        Gem::URI.parse value
+      rescue Gem::URI::InvalidURIError
+        raise Gem::OptionParser::InvalidArgument, value
+      end
     end
 
-    def validate_scheme!(uri, value)
+    def validate_uri!(value)
+      uri = parse_uri(value)
       return if VALID_URI_SCHEMES.include?(uri.scheme)
 
       schemes = VALID_URI_SCHEMES.map { |scheme| "#{scheme}://" }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemvault
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - David Gillis
@@ -9,20 +9,6 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: command_kit
   requirement: !ruby/object:Gem::Requirement
@@ -46,6 +32,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".containerignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
@@ -64,7 +51,9 @@ files:
 - exe/gemvault
 - issues.rec
 - lib/bundler/plugin/vault_source.rb
+- lib/bundler/plugin/vaulted_gem.rb
 - lib/gemvault.rb
+- lib/gemvault/archive_entry.rb
 - lib/gemvault/cli.rb
 - lib/gemvault/cli/command.rb
 - lib/gemvault/cli/commands/add.rb
@@ -80,11 +69,13 @@ files:
 - lib/gemvault/gem_extraction.rb
 - lib/gemvault/gem_reference.rb
 - lib/gemvault/gem_reference/any_version.rb
+- lib/gemvault/gem_reference/parser.rb
 - lib/gemvault/gem_reference/specific_version.rb
 - lib/gemvault/manifest.rb
-- lib/gemvault/tar_archive.rb
+- lib/gemvault/tarball.rb
 - lib/gemvault/tarvault.rb
 - lib/gemvault/vault.rb
+- lib/gemvault/vault_path.rb
 - lib/gemvault/vault_session.rb
 - lib/gemvault/vault_upgrade.rb
 - lib/gemvault/version.rb

data/lib/gemvault/tar_archive.rb

@@ -1,66 +0,0 @@
-require "rubygems/package"
-require "tempfile"
-require "fileutils"
-require_relative "manifest"
-
-module Gemvault
-  # The tar file backing a Tarvault. Reads named entries and rewrites the
-  # whole archive atomically: tar has no index and the leading manifest entry
-  # changes size on every mutation, so mutation means a full rewrite.
-  class TarArchive
-    def initialize(path)
-      @path = path
-    end
-
-    def read(name)
-      bytes = nil
-      each_entry { |entry| bytes = entry.read if entry.full_name == name }
-      bytes
-    end
-
-    def gem_pairs
-      pairs = []
-      each_entry do |entry|
-        pairs << [entry.full_name, entry.read] unless entry.full_name == Manifest::FILENAME
-      end
-      pairs
-    end
-
-    def write(pairs)
-      tmp = Tempfile.create(["tarvault", ".tar"], File.dirname(@path))
-      write_entries(tmp, pairs)
-      tmp.flush
-      tmp.fsync
-      tmp.close
-      File.rename(tmp.path, @path)
-    rescue StandardError
-      cleanup(tmp)
-      raise
-    end
-
-    private
-
-    def each_entry(&)
-      File.open(@path, "rb") do |io|
-        Gem::Package::TarReader.new(io) { |reader| reader.each_entry(&) }
-      end
-    end
-
-    def write_entries(io, pairs)
-      Gem::Package::TarWriter.new(io) do |writer|
-        pairs.each { |name, bytes| add_entry(writer, name, bytes) }
-      end
-    end
-
-    def add_entry(writer, name, bytes)
-      writer.add_file_simple(name, 0o644, bytes.bytesize) { |dest| dest.write(bytes) }
-    end
-
-    def cleanup(tmp)
-      return unless tmp
-
-      tmp.close unless tmp.closed?
-      FileUtils.rm_f(tmp.path)
-    end
-  end
-end