bundler-source-vault 0.1.5 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62096b2c3b6ffd526e3966e2edabb75db044f550297744aea293fb0d2ad44a97
-  data.tar.gz: 7a701f9b39f34b3d49b097b4e34f11bb6bd74903dd928cc0db7bcf575368bc12
+  metadata.gz: 1ef5a7eef66715d1eef861c72b9d99ae3620f507cc67cc3e77ddc9ec388a1e66
+  data.tar.gz: cb6bf98bc161d1d69ddfa628787de932c4768a59cbcfe49ebbf01cec5c9ba739
 SHA512:
-  metadata.gz: e40163ad4c191c4f4a96180c186ea8fb6d39dc6d4cd3881f934af5b8d9607f1a474ca453c79f6061ece769be33bfcd8db187f1c32f4f9f958992b0d3c9596582
-  data.tar.gz: b4ab91d8e009e1ea0f385ddb3c38892db673369a2ce3649c709ce1f218f48324f543cb71ed838d98afd6cb4a2f6e5f24113ce5d9d034d9017b0504f674366429
+  metadata.gz: 495d5668e91b6508baefbfab28cca129e506da744f1026b93b3eecfe4b8623955fb27c74ee7d54f89b8c21bed561470f44ee65a61ace034abc1048dac7305206
+  data.tar.gz: 2c3539ddb5f9f098f39cdbad32747f9aa0d88f013247a464e5a9d8107657cadd621497f24a5f6860f16fe24aea9469815b691923c7f1b16c0af694f5c0b8ad1e

data/gemvault_load_path.rb

@@ -0,0 +1,163 @@
+module BundlerSourceVault
+  # Finds gemvault, and the runtime dependencies it needs, across every gem root
+  # that could hold either, and puts their require paths on $LOAD_PATH.
+  #
+  # Bundler installs a plugin's dependencies alongside the plugin but does not
+  # put them on the load path before loading plugins.rb -- see the "Currently
+  # not done to avoid conflicts" comment in bundler/plugin.rb -- so the shim has
+  # to find gemvault itself.
+  #
+  # $LOAD_PATH rather than activation, because activation cannot survive here:
+  #
+  #   bundler/runtime.rb  clean_load_path runs immediately before specs_for, and
+  #                       resolution is what asks the vault source for specs.
+  #   bundler/shared_helpers.rb
+  #                       clean_load_path strips a $LOAD_PATH entry only when it
+  #                       appears in loaded_gem_paths.
+  #   bundler/rubygems_integration.rb
+  #                       loaded_gem_paths is built from Gem.loaded_specs, so
+  #                       activating is precisely what gets these paths removed
+  #                       one line before they are needed; and stub_rubygems
+  #                       sets Gem::Specification.all to the bundle's own specs,
+  #                       reapplying it via Gem.post_reset, so under bundle exec
+  #                       find_by_name cannot see outside the bundle and reset
+  #                       will not restore it.
+  #
+  # Skipping activation also skips gemvault's dependencies, which is why they
+  # are resolved here by hand. One that cannot be found is left out rather than
+  # raising: command_kit is needed only by the CLI, and activation would have
+  # aborted on it.
+  module GemvaultLoadPath
+    GEM = "gemvault".freeze
+    SHIM = "bundler-source-vault".freeze
+    VAULT_SOURCE = "bundler/plugin/vault_source.rb".freeze
+
+    module_function
+
+    def apply
+      entries.each { |path| $LOAD_PATH.push(path) unless $LOAD_PATH.include?(path) }
+    end
+
+    # Development: loaded from within the gemvault source tree, where the gem is
+    # not installed, so its lib has to lead the search.
+    def source_tree_lib
+      lib = shim_dir.parent.join("lib")
+      lib if lib.join(VAULT_SOURCE).file?
+    end
+
+    # Registering these keeps the roots' specs discoverable to RubyGems, which is
+    # what lets `bundle plugin install` see a gem it has just written into the
+    # plugin root. It has to run on every evaluation, because it does not survive
+    # one: Gem.clear_paths and Gem::Specification.reset, both of which Bundler
+    # calls while configuring the bundle, recompute the dirs from Gem.path.
+    def register_spec_dirs
+      searched = Gem::Specification.dirs.map { |dir| Pathname(dir) }
+      unsearched = install_roots.map { |root| root.join("specifications") }.select(&:directory?) - searched
+      return refresh_stale_spec_cache if unsearched.empty?
+
+      Gem::Specification.dirs = (searched + unsearched).map { |dir| dir.parent.to_s }
+    end
+
+    # The searched dirs are right but the spec cache predates this install:
+    # `bundle plugin install` switches GEM_HOME to the plugin root and caches
+    # specs during resolution, before gemvault lands there.
+    def refresh_stale_spec_cache
+      Gem::Specification.find_by_name(GEM)
+    rescue Gem::LoadError
+      Gem::Specification.reset
+    end
+
+    def entries
+      spec = gemvault_spec
+      return [] unless spec
+
+      [*dependency_specs(spec).flat_map(&:full_require_paths), *spec.full_require_paths]
+    end
+
+    # Prefer the version the shim was released against, read off the shim's own
+    # spec rather than its directory name: that name is a version only for a
+    # plain `gem install`, and never for a source tree, a path: plugin, a git
+    # plugin or a platform gem. With no spec to read, take the newest gemvault
+    # present, which beats whichever the filesystem listed first.
+    def gemvault_spec
+      candidates = specs_named(GEM).select { |spec| vault_source_in?(spec) }
+      pinned = candidates.select { |spec| pinned_requirement.satisfied_by?(spec.version) }
+
+      (pinned.empty? ? candidates : pinned).max_by(&:version)
+    end
+
+    def pinned_requirement
+      dependency = shim_spec&.dependencies&.find { |dep| dep.name == GEM }
+
+      dependency&.requirement || Gem::Requirement.default
+    end
+
+    def shim_spec
+      specs_named(SHIM).find { |spec| spec.full_gem_path == shim_dir.to_s }
+    end
+
+    def dependency_specs(spec)
+      spec.runtime_dependencies.filter_map do |dependency|
+        specs_named(dependency.name)
+          .select { |candidate| dependency.requirement.satisfied_by?(candidate.version) }
+          .max_by(&:version)
+      end
+    end
+
+    def specs_named(name)
+      install_roots
+        .flat_map { |root| root.glob("specifications/#{name}-*.gemspec") }
+        .filter_map { |file| Gem::Specification.load(file.to_s) }
+        .select { |spec| spec.name == name }
+    end
+
+    def vault_source_in?(spec)
+      spec.full_require_paths.any? { |path| Pathname(path).join(VAULT_SOURCE).file? }
+    end
+
+    # Installed, plugins.rb lives at <gem root>/gems/bundler-source-vault-<v>/,
+    # and gemvault may sit in the same root: Bundler's local or global plugin
+    # root, or a plain GEM_HOME. Both plugin roots count, because
+    # Bundler::Plugin.root is the project-local root even when the plugin loads
+    # from the global one.
+    #
+    # Gem.default_path is the load-bearing entry. Bundler skips installing a
+    # plugin dependency that is already installed, so wherever `gem install
+    # gemvault` has run the plugin root holds the shim alone; once the app bundle
+    # is populated Bundler narrows GEM_PATH to it and the ambient gemvault drops
+    # out of Gem.path. Gem.default_path is what RubyGems knows about its own gem
+    # roots regardless of that narrowing. Reading roots back out of the
+    # environment does not cover it -- rubies from rbenv, asdf, chruby, Homebrew
+    # and distros export neither GEM_HOME nor GEM_PATH -- but it still matters
+    # for the ones that export a root outside those defaults, like RVM.
+    def install_roots
+      candidate_roots
+        .reject { |root| root.to_s.empty? }
+        .map { |root| Pathname(root.to_s) }
+        .uniq
+        .select { |root| root.join("specifications").directory? }
+    end
+
+    def candidate_roots
+      [shim_dir.parent.parent, *plugin_roots, *Gem.path, *Gem.default_path, *exported_roots]
+    end
+
+    def plugin_roots
+      return [] unless defined?(Bundler::Plugin)
+
+      [Bundler::Plugin.root, Bundler::Plugin.global_root]
+    end
+
+    def exported_roots
+      return [] unless defined?(Bundler) && Bundler.respond_to?(:original_env)
+
+      original = Bundler.original_env
+
+      [original["GEM_HOME"], *original["GEM_PATH"].to_s.split(File::PATH_SEPARATOR)]
+    end
+
+    def shim_dir
+      Pathname(__dir__)
+    end
+  end
+end

data/plugins.rb

@@ -1,23 +1,23 @@
-# Bundler installs plugin dependencies (e.g. sqlite3) into Plugin.root but
-# does not add their load paths before loading plugins.rb. This is a known
-# Bundler limitation -- see the "Currently not done to avoid conflicts" comment
-# in bundler/plugin.rb#load_plugin.
-#
-# Work around by registering Plugin.root as a gem search path so dependencies
-# installed there are activatable via `require`.
-# Development: when loaded from within the gemvault source tree, the gemvault
-# gem isn't installed so its lib/ must be on $LOAD_PATH for the require below.
-gemvault_lib = File.expand_path("../lib", __dir__)
-$LOAD_PATH.unshift(gemvault_lib) unless $LOAD_PATH.include?(gemvault_lib)
+require_relative "gemvault_load_path"
 
-if defined?(Bundler::Plugin)
-  plugin_root = Bundler::Plugin.root.to_s
-  spec_dir = File.join(plugin_root, "specifications")
-  if File.directory?(spec_dir) && !Gem::Specification.dirs.include?(spec_dir)
-    Gem::Specification.dirs = Gem.path + [plugin_root]
-  end
-end
+# Runs on every evaluation. Bundler discards the registration while configuring
+# the bundle, so it cannot sit behind the guard below.
+BundlerSourceVault::GemvaultLoadPath.register_spec_dirs
+
+# Bundler evaluates this file more than once per process: once when it saves a
+# freshly installed plugin, again when the Gemfile asks for the source. Loading
+# gemvault twice from two different roots is fatal rather than merely noisy,
+# because Gemvault::GemEntry subclasses a fresh Data.define result each time, so
+# a second definition raises a superclass mismatch. Resolve and require only on
+# the first evaluation. The registration above and this one below still repeat --
+# Bundler reads the source back out of Plugin::API after each load.
+unless defined?(Bundler::Plugin::VaultSource)
+  source_tree_lib = BundlerSourceVault::GemvaultLoadPath.source_tree_lib
+  $LOAD_PATH.unshift(source_tree_lib.to_s) if source_tree_lib && !$LOAD_PATH.include?(source_tree_lib.to_s)
 
-require "bundler/plugin/vault_source"
+  BundlerSourceVault::GemvaultLoadPath.apply
+
+  require "bundler/plugin/vault_source"
+end
 
 Bundler::Plugin::API.source("vault", Bundler::Plugin::VaultSource)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bundler-source-vault
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.2
 platform: ruby
 authors:
 - David Gillis
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.5
+        version: 0.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.5
+        version: 0.2.2
 description: Registers the :vault source type with Bundler, enabling gem installation
   from .gemv vault files
 email:
@@ -31,6 +31,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- gemvault_load_path.rb
 - plugins.rb
 homepage: https://github.com/gillisd/gemvault
 licenses:
@@ -52,7 +53,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.17
 specification_version: 4
 summary: Bundler source plugin for gemvault
 test_files: []