gemvault 0.1.4 → 0.2.0

data/lib/bundler/plugin/vault_source.rb

@@ -1,39 +1,71 @@
-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
 
       def fetch_gemspec_files
         validate_vault_exists!
 
         Gemvault::Vault.open(@vault_path) do |vault|
-          vault.gem_entries.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
 
+      # Bundler first asks a source, in local mode, which gems are already
+      # unpacked so it can tell what still needs installing, then switches to
+      # remote mode to resolve and install the rest. A vault gem is not on the
+      # load path until it is unpacked, so advertising one that still lives only
+      # inside the archive makes Bundler believe it is installed: it skips the
+      # install and the later require fails. Advertise not-yet-unpacked gems
+      # only once Bundler has asked for remote specs.
+      def remote!
+        @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
@@ -42,79 +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)
-
-        write_tmp_gemspec(spec.full_name, spec.to_ruby)
-      end
+      def gemspec_file_for(spec)
+        gem = VaultedGem.new(spec)
+        return gem.anchor(spec.to_ruby) if gem.installed?
+        return nil unless @allow_remote
 
-      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
+        write_tmp_gemspec(spec)
       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
+      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 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

@@ -0,0 +1,72 @@
+require_relative "../command"
+require_relative "../../vault_path"
+require_relative "../../vault_upgrade"
+
+module Gemvault
+  class CLI
+    module Commands
+      # Upgrades a vault to the current storage format (e.g. a SQLite Dbvault
+      # to a Tarvault), preserving every gem and its timestamp.
+      class Upgrade < Command
+        description "Upgrade a vault to the current storage format"
+
+        argument :vault, required: true,
+                         usage: "VAULT",
+                         desc: "Vault file"
+
+        option :dry_run, desc: "Show what would change without modifying the vault"
+        option :no_backup, desc: "Do not write a .bak copy before upgrading"
+
+        def run(vault)
+          begin
+            upgrade = build_upgrade(vault)
+            dispatch(vault:, upgrade:)
+          rescue Gemvault::Vault::Error => e
+            print_error(e.message)
+            exit(1)
+          end
+        end
+
+        private
+
+        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:)
+          puts "Would upgrade #{vault}: #{summary} (#{summary.gem_count} gems)"
+        end
+
+        def report_upgraded(vault:, summary:)
+          puts "Upgraded #{vault}: #{summary} (#{summary.gem_count} gems)"
+        end
+      end
+    end
+  end
+end

data/lib/gemvault/dbvault.rb

@@ -0,0 +1,101 @@
+require "sqlite3"
+require "pathname"
+require_relative "vault"
+require_relative "vault_session"
+require_relative "gem_extraction"
+require_relative "gem_entry"
+require_relative "deprecation"
+
+module Gemvault
+  # Read-only reader for a SQLite-backed vault (a "Dbvault"). Attempts to write
+  # are refused with a pointer to run gemvault upgrade, and opening a vault
+  # emits a one-time notice.
+  class Dbvault
+    extend VaultSession
+    include GemExtraction
+
+    FORMAT_VERSION = 1
+
+    attr_reader :path
+
+    def initialize(path)
+      @path = Pathname(path).expand_path
+      open_vault!
+    end
+
+    def add(*)
+      raise Vault::ReadOnlyError, read_only_message
+    end
+
+    def remove(*)
+      raise Vault::ReadOnlyError, read_only_message
+    end
+
+    def gem_data(entry)
+      row = @db.execute(
+        "SELECT data FROM gems WHERE name = ? AND version = ? AND platform = ?",
+        [entry.name, entry.version, entry.platform],
+      ).first
+      raise Vault::NotFoundError, "Gem not found: #{entry}" unless row
+
+      row["data"]
+    end
+
+    def gem_entries
+      @db.execute(
+        "SELECT name, version, platform, created_at FROM gems ORDER BY name, version",
+      ).map { |row| GemEntry.new(**row.transform_keys(&:to_sym)) }
+    end
+
+    def size
+      @db.execute("SELECT COUNT(*) AS count FROM gems").first["count"]
+    end
+
+    def close
+      @db.close if @db && !@db.closed?
+    end
+
+    def closed?
+      @db.nil? || @db.closed?
+    end
+
+    def format_version
+      row = @db.execute("SELECT value FROM metadata WHERE key = 'vault_version'").first
+      return FORMAT_VERSION unless row
+
+      row["value"].to_i
+    end
+
+    private
+
+    def open_vault!
+      raise Vault::NotFoundError, "Vault not found: #{@path}" unless @path.exist?
+
+      validate_sqlite!
+      @db = new_database
+      Vault.assert_readable!(version: format_version, path: @path)
+      Deprecation.warn_once(deprecation_message)
+    end
+
+    def new_database
+      db = SQLite3::Database.new(@path.to_s)
+      db.results_as_hash = true
+      db
+    end
+
+    def validate_sqlite!
+      return if @path.binread(Vault::SQLITE_MAGIC.bytesize) == Vault::SQLITE_MAGIC
+
+      raise Vault::Error, "Not a valid vault file (not SQLite): #{@path}"
+    end
+
+    def read_only_message
+      "#{@path} uses the deprecated read-only SQLite format. Migrate it first: gemvault upgrade #{@path}"
+    end
+
+    def deprecation_message
+      "SQLite vaults are deprecated and read-only; support will be removed in a future release (0.3-0.5). " \
+        "Migrate #{@path} with: gemvault upgrade #{@path}"
+    end
+  end
+end

data/lib/gemvault/deprecation.rb

@@ -0,0 +1,48 @@
+module Gemvault
+  # Emits deprecation notices once per unique message, to a configurable IO
+  # (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
+
+    attr_writer :output
+
+    def output
+      @output ||= $stderr
+    end
+
+    def warn_once(message)
+      return if silenced?
+      return unless seen.add?(message)
+
+      output.puts("gemvault: #{message}")
+    end
+
+    def silence
+      previous = @silenced
+      @silenced = true
+      begin
+        yield
+      ensure
+        @silenced = previous
+      end
+    end
+
+    def silenced?
+      @silenced || ENV.key?(ENV_KEY)
+    end
+
+    def reset!
+      @seen = Set.new
+      @silenced = false
+    end
+
+    private
+
+    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