gemvault 0.1.5 → 0.2.0

data/lib/bundler/plugin/vault_source.rb

@@ -1,13 +1,18 @@
-require "fileutils"
+require "pathname"
+require_relative "vaulted_gem"
 require_relative "../../gemvault/vault"
+require_relative "../../gemvault/gem_entry"
 
 module Bundler
   module Plugin
-    # Bundler plugin source that installs gems from a .gemv vault file.
+    # Bundler plugin source that installs gems from a .gemv vault file. A thin
+    # doorway over the Bundler Source API: it resolves the vault path, hands
+    # Bundler the gemspecs it can install, and delegates each gem's placement in
+    # the bundle to a VaultedGem.
     class VaultSource
       def initialize(opts)
         super
-        @vault_path = resolve_vault_path(@uri)
+        @vault_path = Pathname(@uri).expand_path(Bundler.root)
         @allow_remote = false
       end
 
@@ -15,7 +20,9 @@ module Bundler
         validate_vault_exists!
 
         Gemvault::Vault.open(@vault_path) do |vault|
-          vault.gem_entries.filter_map { |entry| gemspec_file_for(vault, entry) }
+          vault.gem_entries
+               .map { |entry| vault.spec_from_blob(entry) }
+               .filter_map { |spec| gemspec_file_for(spec) }
         end
       end
 
@@ -30,22 +37,35 @@ module Bundler
         @allow_remote = true
       end
 
+      # The inverse of remote!. Bundler's local-only resolve (Definition#check!,
+      # reached by `bundle check`) calls local_only! on every source. The base
+      # Bundler::Plugin::API::Source defines no such hook, so without this the
+      # command dies with NoMethodError; here it simply stops advertising gems
+      # that live only inside the archive.
+      def local_only!
+        @allow_remote = false
+      end
+
+      # Also invoked on every source during resolution (Definition#prefer_local!,
+      # for `--prefer-local`). The vault reads from one local file already, so
+      # there is no remote to deprioritize.
+      def prefer_local!; end
+
       def install(spec, opts = {})
-        gem_dir = gem_dir_for(spec.full_name)
-        return use_installed_gem(spec, gem_dir) if File.directory?(gem_dir) && !opts[:force]
+        gem = VaultedGem.new(spec)
+        return gem.adopt if gem.installed? && !opts[:force]
 
-        Bundler.ui.confirm "Installing #{version_message(spec)} from vault #{@uri}"
-        install_into_bundle(spec, opts)
-        spec.post_install_message
+        Bundler.ui.confirm "Installing #{gem.version_message} from vault #{@uri}"
+        extract(spec) { |gem_path| gem.install(gem_path:, build_args: opts[:build_args] || []) }
       end
 
       def options_to_lock
         {}
       end
 
-      # No source-level install_path to copy: VaultSource#install installs
-      # each gem into Bundler.bundle_path via RubyGemsGemInstaller, so the
-      # default Source#cache would dereference a non-existent directory.
+      # No source-level install_path to copy: VaultSource#install installs each
+      # gem into Bundler.bundle_path via RubyGemsGemInstaller, so the default
+      # Source#cache would dereference a non-existent directory.
       def cache(spec, custom_path = nil); end
 
       def to_s
@@ -54,80 +74,35 @@ module Bundler
 
       private
 
-      def gemspec_file_for(vault, entry)
-        spec = vault.spec_from_blob(entry.name, entry.version, entry.platform)
-        gem_dir = gem_dir_for(spec.full_name)
-        return anchor_gemspec(gem_dir, spec.full_name, spec.to_ruby) if File.directory?(gem_dir)
+      def gemspec_file_for(spec)
+        gem = VaultedGem.new(spec)
+        return gem.anchor(spec.to_ruby) if gem.installed?
         return nil unless @allow_remote
 
-        write_tmp_gemspec(spec.full_name, spec.to_ruby)
+        write_tmp_gemspec(spec)
       end
 
-      def write_tmp_gemspec(full_name, spec_ruby)
-        gemspec_dir = File.join(Bundler.tmp("vault_source"), "specifications")
-        FileUtils.mkdir_p(gemspec_dir)
-        gemspec_path = File.join(gemspec_dir, "#{full_name}.gemspec")
-        File.write(gemspec_path, spec_ruby)
-        gemspec_path
+      def write_tmp_gemspec(spec)
+        tmp_dir = Pathname(Bundler.tmp("vault_source"))
+        gemspec_dir = tmp_dir / "specifications"
+        gemspec_dir.mkpath
+        gemspec = gemspec_dir / "#{spec.full_name}.gemspec"
+        gemspec.write(spec.to_ruby)
+        gemspec.to_s
       end
 
-      def use_installed_gem(spec, gem_dir)
-        Bundler.ui.debug "Using #{version_message(spec)} from vault #{@uri}"
-        spec.full_gem_path = gem_dir
-        spec.loaded_from = File.join(gem_dir, "#{spec.full_name}.gemspec")
-        nil
-      end
-
-      def install_into_bundle(spec, opts)
+      def extract(spec, &)
         Gemvault::Vault.open(@vault_path) do |vault|
-          vault.with_gem_file(spec.name, spec.version.to_s, platform: spec.platform.to_s) do |gem_path|
-            installed_spec = build_installer(gem_path, opts).install
-            gem_dir = installed_spec.full_gem_path
-            spec.full_gem_path = gem_dir
-            spec.loaded_from = anchor_gemspec(gem_dir, spec.full_name, installed_spec.to_ruby)
-          end
+          vault.with_gem_file(entry_for(spec), &)
         end
       end
 
-      def build_installer(gem_path, opts)
-        require "bundler/rubygems_gem_installer"
-
-        Bundler::RubyGemsGemInstaller.at(
-          gem_path,
-          install_dir: Bundler.bundle_path.to_s,
-          bin_dir: Bundler.system_bindir.to_s,
-          ignore_dependencies: true,
-          wrappers: true,
-          env_shebang: true,
-          build_args: opts[:build_args] || [],
-        )
-      end
-
-      def version_message(spec)
-        message = "#{spec.name} #{spec.version}"
-        message += " (#{spec.platform})" if spec.platform != Gem::Platform::RUBY && !spec.platform.nil?
-        message
-      end
-
-      def resolve_vault_path(uri)
-        File.expand_path(uri, Bundler.root.to_s)
-      end
-
-      # Bundler computes full_gem_path as dirname(loaded_from) for plugin
-      # sources, so the gemspec must live inside the gem directory -- not
-      # in specifications/ -- for load paths to resolve correctly.
-      def anchor_gemspec(gem_dir, full_name, spec_ruby)
-        gemspec_path = File.join(gem_dir, "#{full_name}.gemspec")
-        File.write(gemspec_path, spec_ruby) unless File.exist?(gemspec_path)
-        gemspec_path
-      end
-
-      def gem_dir_for(full_name)
-        File.join(Bundler.bundle_path, "gems", full_name)
+      def entry_for(spec)
+        Gemvault::GemEntry.from_spec(spec)
       end
 
       def validate_vault_exists!
-        return if File.file?(@vault_path)
+        return if @vault_path.file?
 
         raise Bundler::PathError,
               "Could not find vault '#{@uri}' referenced in Gemfile " \

data/lib/bundler/plugin/vaulted_gem.rb

@@ -0,0 +1,66 @@
+require "pathname"
+
+module Bundler
+  module Plugin
+    # A gem sourced from a vault as it lives (or will live) inside the bundle.
+    # Owns where the gem unpacks, whether it is already installed, installing an
+    # extracted .gem file, and anchoring its gemspec inside the gem directory --
+    # Bundler derives full_gem_path from dirname(loaded_from), so the gemspec
+    # must sit beside the gem, not in specifications/.
+    class VaultedGem
+      def initialize(spec)
+        @spec = spec
+        @gem_dir = Bundler.bundle_path.join("gems", spec.full_name)
+      end
+
+      def installed?
+        @gem_dir.directory?
+      end
+
+      def version_message
+        message = "#{@spec.name} #{@spec.version}"
+        message += " (#{@spec.platform})" if @spec.platform != Gem::Platform::RUBY && !@spec.platform.nil?
+        message
+      end
+
+      # Point the Bundler spec at the already-unpacked gem.
+      def adopt
+        Bundler.ui.debug "Using #{version_message} from vault"
+        @spec.full_gem_path = @gem_dir.to_s
+        @spec.loaded_from = anchor(@spec.to_ruby)
+        nil
+      end
+
+      # Install the extracted .gem file into the bundle, point the spec at it,
+      # and return its post-install message.
+      def install(gem_path:, build_args:)
+        installed = installer(gem_path:, build_args:).install
+        @spec.full_gem_path = installed.full_gem_path
+        @spec.loaded_from = anchor(installed.to_ruby, dir: installed.full_gem_path)
+        @spec.post_install_message
+      end
+
+      def anchor(spec_ruby, dir: @gem_dir)
+        gemspec = Pathname(dir).join("#{@spec.full_name}.gemspec")
+        gemspec.write(spec_ruby) unless gemspec.exist?
+        gemspec.to_s
+      end
+
+      private
+
+      def installer(gem_path:, build_args:)
+        require "bundler/rubygems_gem_installer"
+
+        Bundler::RubyGemsGemInstaller.at(
+          gem_path,
+          install_dir: Bundler.bundle_path.to_s,
+          bin_dir: Bundler.system_bindir.to_s,
+          ignore_dependencies: true,
+          wrappers: true,
+          env_shebang: true,
+          build_args:,
+        )
+      end
+    end
+  end
+end

data/lib/gemvault/archive_entry.rb

@@ -0,0 +1,6 @@
+module Gemvault
+  # One member of a vault's tar archive: a named blob of bytes. A value object
+  # so archive code names what it moves around instead of juggling raw arrays.
+  class ArchiveEntry < Data.define(:name, :bytes)
+  end
+end

data/lib/gemvault/cli/command.rb

@@ -1,5 +1,6 @@
 require "command_kit/command"
 require_relative "../vault"
+require_relative "../vault_path"
 
 module Gemvault
   class CLI
@@ -7,11 +8,14 @@ module Gemvault
     class Command < CommandKit::Command
       private
 
-      def with_vault(path, create: false, &block)
-        Gemvault::Vault.open(path, create: create, &block)
-      rescue Gemvault::Vault::Error => e
-        print_error(e.message)
-        exit(1)
+      def with_vault(locator, create: false, &block)
+        begin
+          path = VaultPath.resolve(locator)
+          Gemvault::Vault.open(path, create:, &block)
+        rescue Gemvault::Vault::Error => e
+          print_error(e.message)
+          exit(1)
+        end
       end
     end
   end

data/lib/gemvault/cli/commands/extract.rb

@@ -1,4 +1,4 @@
-require "fileutils"
+require "pathname"
 require_relative "../command"
 
 module Gemvault
@@ -25,21 +25,21 @@ module Gemvault
                         desc: "Output directory"
 
         def run(vault, name, version = nil)
-          output_dir = options[:output]
+          output_dir = Pathname(options[:output])
 
           with_vault(vault) do |v|
-            ::FileUtils.mkdir_p(output_dir)
-            entries = matching_entries(v, name, version)
+            output_dir.mkpath
+            entries = matching_entries(vault: v, name:, version:)
             abort_missing_gem(name) if entries.empty?
-            extract_entries(v, entries, output_dir)
+            extract_entries(vault: v, entries:, output_dir:)
           end
         end
 
         private
 
-        def matching_entries(vault, name, version)
-          entries = vault.gem_entries.select { |e| e.name == name }
-          version ? entries.select { |e| e.version == version } : entries
+        def matching_entries(vault:, name:, version:)
+          entries = vault.gem_entries.select { |entry| entry.name == name }
+          version ? entries.select { |entry| entry.version == version } : entries
         end
 
         def abort_missing_gem(name)
@@ -47,10 +47,10 @@ module Gemvault
           exit(1)
         end
 
-        def extract_entries(vault, entries, output_dir)
+        def extract_entries(vault:, entries:, output_dir:)
           entries.each do |entry|
-            data = vault.gem_data(entry.name, entry.version, platform: entry.platform)
-            File.binwrite(File.join(output_dir, entry.filename), data)
+            data = vault.gem_data(entry)
+            (output_dir / entry.filename).binwrite(data)
             puts "Extracted #{entry.filename}"
           end
         end

data/lib/gemvault/cli/commands/new.rb

@@ -1,3 +1,4 @@
+require "pathname"
 require_relative "../command"
 
 module Gemvault
@@ -12,9 +13,9 @@ module Gemvault
                         desc: "Vault name (auto-appends .gemv)"
 
         def run(name)
-          path = name.end_with?(".gemv") ? name : "#{name}.gemv"
+          path = Pathname(name.end_with?(".gemv") ? name : "#{name}.gemv")
 
-          if File.exist?(path)
+          if path.exist?
             print_error("#{path} already exists")
             exit(1)
           end

data/lib/gemvault/cli/commands/remove.rb

@@ -26,15 +26,25 @@ module Gemvault
                          desc: "Gem version (overrides positional and NAME-VERSION forms)"
 
         def run(vault, name, positional_version = nil)
-          ref = Gemvault::GemReference.parse(name, version: options[:version] || positional_version)
-          with_vault(vault) { |v| report_removal(v.remove(ref)) }
-        rescue Gemvault::GemReference::NonExactVersionError => e
-          print_error(e.message)
-          exit(1)
+          begin
+            version = options[:version] || positional_version
+            reference = Gemvault::GemReference.parse(name, version:)
+            remove_matching(vault:, reference:)
+          rescue Gemvault::GemReference::NonExactVersionError => e
+            print_error(e.message)
+            exit(1)
+          end
         end
 
         private
 
+        def remove_matching(vault:, reference:)
+          with_vault(vault) do |v|
+            removed = v.remove(reference)
+            report_removal(removed)
+          end
+        end
+
         def report_removal(count)
           if count.zero?
             print_error("No matching gem found")

data/lib/gemvault/cli/commands/upgrade.rb

@@ -1,4 +1,5 @@
 require_relative "../command"
+require_relative "../../vault_path"
 require_relative "../../vault_upgrade"
 
 module Gemvault
@@ -17,29 +18,52 @@ module Gemvault
         option :no_backup, desc: "Do not write a .bak copy before upgrading"
 
         def run(vault)
-          upgrade = Gemvault::VaultUpgrade.new(vault, backup: !options[:no_backup])
-          summary = upgrade.plan
-          return report_no_op(vault, summary) if summary.no_op?
-          return report_dry_run(vault, summary) if options[:dry_run]
-
-          upgrade.call
-          report_upgraded(vault, summary)
-        rescue Gemvault::Vault::Error => e
-          print_error(e.message)
-          exit(1)
+          begin
+            upgrade = build_upgrade(vault)
+            dispatch(vault:, upgrade:)
+          rescue Gemvault::Vault::Error => e
+            print_error(e.message)
+            exit(1)
+          end
         end
 
         private
 
-        def report_no_op(vault, summary)
+        def build_upgrade(vault)
+          path = VaultPath.resolve(vault)
+          Gemvault::VaultUpgrade.new(path, backup: backup?)
+        end
+
+        def backup?
+          !options[:no_backup]
+        end
+
+        def dispatch(vault:, upgrade:)
+          summary = upgrade.plan
+          case decision(summary)
+          in { no_op: true }
+            report_no_op(vault:, summary:)
+          in { dry_run: true }
+            report_dry_run(vault:, summary:)
+          else
+            upgrade.call
+            report_upgraded(vault:, summary:)
+          end
+        end
+
+        def decision(summary)
+          { no_op: summary.no_op?, dry_run: options[:dry_run] }
+        end
+
+        def report_no_op(vault:, summary:)
           puts "#{vault} is already current (format #{summary.to_version})"
         end
 
-        def report_dry_run(vault, summary)
+        def report_dry_run(vault:, summary:)
           puts "Would upgrade #{vault}: #{summary} (#{summary.gem_count} gems)"
         end
 
-        def report_upgraded(vault, summary)
+        def report_upgraded(vault:, summary:)
           puts "Upgraded #{vault}: #{summary} (#{summary.gem_count} gems)"
         end
       end

data/lib/gemvault/dbvault.rb

@@ -1,4 +1,5 @@
 require "sqlite3"
+require "pathname"
 require_relative "vault"
 require_relative "vault_session"
 require_relative "gem_extraction"
@@ -18,7 +19,7 @@ module Gemvault
     attr_reader :path
 
     def initialize(path)
-      @path = File.expand_path(path)
+      @path = Pathname(path).expand_path
       open_vault!
     end
 
@@ -30,12 +31,12 @@ module Gemvault
       raise Vault::ReadOnlyError, read_only_message
     end
 
-    def gem_data(name, version, platform: "ruby")
+    def gem_data(entry)
       row = @db.execute(
         "SELECT data FROM gems WHERE name = ? AND version = ? AND platform = ?",
-        [name, version, platform],
+        [entry.name, entry.version, entry.platform],
       ).first
-      raise Vault::NotFoundError, "Gem not found: #{name}-#{version} (#{platform})" unless row
+      raise Vault::NotFoundError, "Gem not found: #{entry}" unless row
 
       row["data"]
     end
@@ -60,28 +61,30 @@ module Gemvault
 
     def format_version
       row = @db.execute("SELECT value FROM metadata WHERE key = 'vault_version'").first
-      row ? row["value"].to_i : FORMAT_VERSION
+      return FORMAT_VERSION unless row
+
+      row["value"].to_i
     end
 
     private
 
     def open_vault!
-      raise Vault::NotFoundError, "Vault not found: #{@path}" unless File.exist?(@path)
+      raise Vault::NotFoundError, "Vault not found: #{@path}" unless @path.exist?
 
       validate_sqlite!
       @db = new_database
-      Vault.assert_readable!(format_version, @path)
+      Vault.assert_readable!(version: format_version, path: @path)
       Deprecation.warn_once(deprecation_message)
     end
 
     def new_database
-      db = SQLite3::Database.new(@path)
+      db = SQLite3::Database.new(@path.to_s)
       db.results_as_hash = true
       db
     end
 
     def validate_sqlite!
-      return if File.binread(@path, Vault::SQLITE_MAGIC.bytesize) == Vault::SQLITE_MAGIC
+      return if @path.binread(Vault::SQLITE_MAGIC.bytesize) == Vault::SQLITE_MAGIC
 
       raise Vault::Error, "Not a valid vault file (not SQLite): #{@path}"
     end

data/lib/gemvault/deprecation.rb

@@ -3,44 +3,46 @@ module Gemvault
   # (stderr in production). Silenceable per-block or via an environment opt-out
   # so automated pipelines that consume a legacy vault are not spammed.
   module Deprecation
+    extend self
+
     ENV_KEY = "GEMVAULT_SILENCE_DEPRECATIONS".freeze
 
-    class << self
-      attr_writer :output
+    attr_writer :output
 
-      def output
-        @output ||= $stderr
-      end
+    def output
+      @output ||= $stderr
+    end
 
-      def warn_once(message)
-        return if silenced? || seen.include?(message)
+    def warn_once(message)
+      return if silenced?
+      return unless seen.add?(message)
 
-        seen << message
-        output.puts("gemvault: #{message}")
-      end
+      output.puts("gemvault: #{message}")
+    end
 
-      def silence
-        previous = @silenced
-        @silenced = true
+    def silence
+      previous = @silenced
+      @silenced = true
+      begin
         yield
       ensure
         @silenced = previous
       end
+    end
 
-      def silenced?
-        @silenced || ENV.key?(ENV_KEY)
-      end
+    def silenced?
+      @silenced || ENV.key?(ENV_KEY)
+    end
 
-      def reset!
-        @seen = []
-        @silenced = false
-      end
+    def reset!
+      @seen = Set.new
+      @silenced = false
+    end
 
-      private
+    private
 
-      def seen
-        @seen ||= []
-      end
+    def seen
+      @seen ||= Set.new
     end
   end
 end

data/lib/gemvault/gem_entry.rb

@@ -1,38 +1,34 @@
 module Gemvault
-  # Value object for one gem row (name, version, platform, created_at) in a vault.
-  class GemEntry
-    attr_reader :name, :version, :platform, :created_at
+  # Value object for one gem's identity (name, version, platform) and the time
+  # it was stored in a vault. Equality, hashing, and to_h come from Data.
+  class GemEntry < Data.define(:name, :version, :platform, :created_at)
+    RUBY_PLATFORM_NAME = "ruby".freeze
 
-    def initialize(name:, version:, platform: "ruby", created_at: nil)
-      @name = name
-      @version = version
-      @platform = platform
-      @created_at = created_at
+    ##
+    # Builds an entry from a <tt>Gem::Specification</tt> (or any object with
+    # +name+, +version+, and +platform+), stringifying the version and platform.
+    def self.from_spec(spec, created_at: nil)
+      new(name: spec.name, version: spec.version.to_s, platform: spec.platform.to_s, created_at:)
     end
 
-    def full_name
-      platform == "ruby" ? "#{name}-#{version}" : "#{name}-#{version}-#{platform}"
+    def initialize(name:, version:, platform: RUBY_PLATFORM_NAME, created_at: nil)
+      super
     end
 
-    def filename
-      "#{full_name}.gem"
-    end
+    def ruby_platform? = platform == RUBY_PLATFORM_NAME
 
-    def to_s
-      platform == "ruby" ? "#{name}-#{version}" : "#{name}-#{version} (#{platform})"
+    def full_name
+      ruby_platform? ? "#{name}-#{version}" : "#{name}-#{version}-#{platform}"
     end
 
-    def ==(other)
-      other.is_a?(self.class) &&
-        name == other.name &&
-        version == other.version &&
-        platform == other.platform
-    end
+    def filename = "#{full_name}.gem"
 
-    alias eql? ==
+    def same_identity_as?(other)
+      name == other.name && version == other.version && platform == other.platform
+    end
 
-    def hash
-      [name, version, platform].hash
+    def to_s
+      ruby_platform? ? "#{name}-#{version}" : "#{name}-#{version} (#{platform})"
     end
   end
 end