bundler-source-pathext 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c60ff2869c3dd24a8af2baf53c12732d91ab94f7e0da7118ee89d69564c2fd60
-  data.tar.gz: dbb33d23f6d3958b156c6d3549f5faaecabd2955ed2a056258af62b48577c500
+  metadata.gz: 74f39d19bde0adf306918257f3c5fffb56084f083adbc66e56045f7662cfb445
+  data.tar.gz: 4369b733c6b795dc497f8aeaa6477bcd957b72583801a4279e63f0b2d8ca000e
 SHA512:
-  metadata.gz: a39f6d46858cd5a27108e937cb30a57238d3d73170a4151ec0511b9c5e2a63146921d65a1f4d27abb9d24cf65608456a97cfca8958f1f4cc558301747431d707
-  data.tar.gz: '0883191629d3506483e81fbeb2ed687ba666a79eb5c5034e16d5d0c1deea2bd14a49d013938359584304a498a4fdb4fb4c98bf07fd24660d74f57144ca02ef00'
+  metadata.gz: b51052c526b45864b3be82804cd2647eebdf462e73e1220232362d6cf86331b3aee1ecea49c892ae789769f8823027eccb951f8f0f159e3ce09086f648bd890d
+  data.tar.gz: d46411773b33d982fb0b03608670cdbca622cb5179e23a3675929989743a7eec943eebde776c16a8e40e5c3dd74d051d86adb196a5b8d7f77949dd607b10991e

data/.github/workflows/test.yml

@@ -0,0 +1,34 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    name: Ruby ${{ matrix.ruby }} / Bundler ${{ matrix.bundler }} / ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        ruby: ['3.2', '3.3', '3.4', '4.0']
+        bundler: ['2.5.22', '2.6.9', 'latest']
+        include:
+          - os: macos-latest
+            ruby: '4.0'
+            bundler: 'latest'
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler: ${{ matrix.bundler }}
+
+      - run: bundle --version
+
+      # Note this intentionally does not run through bundler, since the tests
+      # shell out to "bundle install" in a temporary app of their own
+      - run: ruby test/integration_test.rb

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bundler-source-pathext (0.3.0)
+    bundler-source-pathext (0.4.1)
 
 GEM
   remote: https://rubygems.org/
@@ -11,10 +11,11 @@ GEM
 PLATFORMS
   arm64-darwin-24
   x86_64-darwin-17
+  x86_64-linux
 
 DEPENDENCIES
   bundler-source-pathext!
   rake (~> 12.0)
 
 BUNDLED WITH
-   2.2.3
+  4.1.0.beta2

data/README.md

@@ -1,8 +1,13 @@
-# bundle-source-pathext [ ![](https://img.shields.io/gem/v/bundle-source-pathext.svg)](https://rubygems.org/gems/bundle-source-pathext) [ ![](https://img.shields.io/gem/dt/bundle-source-pathext.svg)](https://rubygems.org/gems/bundle-source-pathext)
+# bundler-source-pathext
+[ ![](https://img.shields.io/gem/v/bundler-source-pathext.svg)](https://rubygems.org/gems/bundler-source-pathext)
+[ ![](https://img.shields.io/gem/dt/bundler-source-pathext.svg)](https://rubygems.org/gems/bundler-source-pathext)
+[ ![](https://github.com/pganalyze/bundler-path-build-ext/actions/workflows/test.yml/badge.svg)](https://github.com/pganalyze/bundler-path-build-ext/actions/workflows/test.yml)
 
-This bundler plugin allows building local Ruby extensions that are referred to by a local path, similar to how gems are built when they are fetched from a remote path.
+This bundler plugin allows building local Ruby extensions that are referred to by a local path,
+similar to how gems are built when they are fetched from a remote path.
 
-Rubygems/Bundler itself unfortunately does not build local extensions automatically, making workflows complicated that utilize gems with an extension build, as part of an application.
+Rubygems/Bundler itself unfortunately does not build local extensions automatically, making
+workflows complicated that utilize gems with an extension build, as part of an application.
 
 ## Usage
 
@@ -14,7 +19,22 @@ source './folder', type: 'pathext' do
 end
 ```
 
-Different from Rubygems, this plugin uses a modified version of [Gem::Ext::Builder](https://github.com/ruby/rubygems/blob/master/lib/rubygems/ext/builder.rb) for Ruby extensions with an "extconf" folder, that does not create an additional copy of the created binaries in the extension install folder. This is done to avoid caching issues where the version in the extension install folder gets stale.
+Different from Rubygems, this plugin uses a modified version of
+[Gem::Ext::Builder](https://github.com/ruby/rubygems/blob/master/lib/rubygems/ext/builder.rb) for
+Ruby extensions with an "extconf" folder.
+
+Rubygems installs the built binaries into the gem's `lib` folder, and keeps a second copy in the
+extension install folder, but only creates that copy when it does not exist yet. For a local gem,
+whose version does not change when its source does, that second copy goes stale. This plugin
+installs into a single location instead, and always overwrites it: the gem's `lib` folder when
+Rubygems installs extensions there (which is the default, see `install_extension_in_lib`), and the
+extension install folder (`tmp/PLATFORM/GEM/RUBY_VERSION` inside the gem) otherwise. Note that
+cross-compilation is not supported.
+
+## Compatibility
+
+Tested against Bundler 2.5, 2.6 and the current release, see the
+[test workflow](.github/workflows/test.yml) for the versions that are covered.
 
 ## LICENSE
 

data/Rakefile

@@ -1,2 +1,8 @@
 require "bundler/gem_tasks"
-task :default => :spec
+
+desc "Run the integration tests"
+task :test do
+  ruby "test/integration_test.rb"
+end
+
+task :default => :test

data/bundler-source-pathext.gemspec

@@ -1,12 +1,15 @@
 Gem::Specification.new do |spec|
   spec.name          = "bundler-source-pathext"
-  spec.version       = "0.3.0"
+  spec.version       = "0.4.1"
   spec.authors       = ["pganalyze Team"]
   spec.email         = ["team@pganalyze.com"]
 
-  spec.summary = ''
-  spec.description = ''
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.summary = 'Bundler source plugin for local gems with native extensions'
+  spec.description = 'Bundler source plugin that works like a path source, but also builds the ' \
+                     'native extensions of the gems it provides, like a remote gem source does.'
+  spec.homepage = 'https://github.com/pganalyze/bundler-path-build-ext'
+  spec.license = 'BSD-3-Clause'
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.

data/lib/bundler-source-pathext.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'rubygems/ext'
+
+class BundlerSourcePathext < Bundler::Plugin::API
+  # Gem::Ext::Builder gained a target_rbconfig argument (for cross-compilation)
+  # in Rubygems 3.6, and an n_jobs keyword argument in Rubygems 4.0.2
+  HAS_TARGET_RBCONFIG = Gem.rubygems_version >= Gem::Version.new("3.6")
+  HAS_NJOBS = Gem.rubygems_version >= Gem::Version.new("4.0.2")
+
+  class PathExtSource < Bundler::Source
+    # Where each source's relative path is resolved from, keyed by its uri.
+    #
+    # Bundler builds a source twice: once from the Gemfile, and once from the
+    # lockfile, and it keeps the latter (see Definition#converge_sources). The
+    # lockfile records nothing but the relative remote, so the rebuilt source
+    # cannot tell which Gemfile that path was written in - but the Gemfile is
+    # always evaluated before the lockfile is parsed, so the copy that does know
+    # leaves the answer here for the copy that doesn't.
+    ROOT_PATHS = {}
+
+    # Bundler hands its own path source the directory that relative paths are
+    # resolved against, as "root_path", but it does not do so for plugin sources,
+    # so we work it out ourselves below. Accepting the option regardless means we
+    # pick it up for free if Bundler ever starts passing it.
+    def initialize(opts)
+      super
+      root_path = opts['root_path'] || declaring_gemfile_dir(caller_locations)
+      ROOT_PATHS[uri] = root_path if root_path
+      @root_path = ROOT_PATHS[uri] || root
+    end
+
+    # Called by Bundler once per gem that gets installed from this source.
+    #
+    # Note that `opts` are the install options passed in by Bundler (:build_args,
+    # :previous_spec, ...), whereas `options` are the source options that came
+    # from the Gemfile or the lockfile.
+    def install(spec, opts = {})
+      using_message = "Using #{version_message(spec, opts[:previous_spec])} from #{self}"
+      using_message += " and installing its executables" unless spec.executables.empty?
+      print_using_message using_message
+
+      # Bundler's installer would build the extensions into the regular extension
+      # directory, we build them ourselves below instead
+      generate_bin(spec, disable_extensions: true)
+
+      build_local_extensions(spec, opts[:build_args])
+
+      nil # no post-install message
+    end
+
+    # Bundler plugin api, we need to return a Bundler::Index
+    def specs
+      # A relative path in the Gemfile is relative to the Gemfile itself, and not
+      # to the directory bundler was run from
+      files = Dir.glob(File.join(File.expand_path(uri, @root_path), '*.gemspec'))
+
+      Bundler::Index.build do |index|
+        files.each do |file|
+          next unless spec = Bundler.load_gemspec(file)
+          spec.installed_by_version = Gem::VERSION
+          spec.source = self
+          spec.extension_dir = File.join(File.dirname(file), 'tmp', RUBY_PLATFORM, spec.name, RUBY_VERSION)
+          Bundler.rubygems.validate(spec)
+
+          index << spec
+        end
+      end
+    end
+
+    # The gems are always used in place, so there is nothing to fetch, cache or
+    # refresh here - all of these are intentional no-ops:
+    #
+    # local!  - fetch the specs and install from the local system
+    # remote! - fetch the specs and install from a remote path
+    # cached! - fetch the specs and install from `app_cache_path`
+    # unlock! - refresh the cache/specs (e.g. git sources make a fresh clone)
+    def local!; end
+    def remote!; end
+    def cached!; end
+    def unlock!; end
+
+    private
+
+    # Bundler.root is the directory of the Gemfile bundler was pointed at, which
+    # is not necessarily the one that declared this source: a wrapper Gemfile
+    # that pulls the real one in through eval_gemfile (as the Ruby LSP and
+    # Appraisal do) moves the root into its own directory, while the source path
+    # still refers to the Gemfile it was written in.
+    #
+    # Bundler evaluates every Gemfile with `instance_eval(contents, gemfile_path)`,
+    # so while a source is being declared the Gemfile is the innermost frame
+    # outside of bundler, and its caller is bundler's DSL. Requiring both keeps
+    # an ordinary bundler stack from being mistaken for a Gemfile: a source
+    # rebuilt from the lockfile has no Gemfile frame, and falls back to the root.
+    def declaring_gemfile_dir(locations)
+      dsl = Bundler::Dsl.instance_method(:eval_gemfile).source_location.first
+      bundler_lib = File.dirname(File.dirname(dsl)) + File::SEPARATOR
+
+      index = locations.index { |location| !location.path.start_with?(bundler_lib) }
+      return if index.nil? || index.zero?
+      return unless locations[index - 1].path == dsl
+
+      File.dirname(File.expand_path(locations[index].path))
+    end
+
+    def build_local_extensions(spec, build_args = nil)
+      # Bundler passes in whatever "bundle config build.GEM" is set to, and the
+      # source options allow setting build args for all gems of a source
+      build_args = Array(build_args)
+      build_args = Array(options['build_args']) if build_args.empty?
+      build_args = Array(Bundler.rubygems.build_args) if build_args.empty?
+
+      builder = Gem::Ext::Builder.new spec, build_args
+
+      build_extensions(spec, build_args, builder)
+    end
+
+    def build_extensions(spec, build_args, builder)
+      return if spec.extensions.empty?
+
+      if build_args.empty?
+        Bundler.ui.info "Building native extensions for #{spec.name}. This could take a while..."
+      else
+        Bundler.ui.info "Building native extensions for #{spec.name} with: '#{build_args.join " "}'"
+        Bundler.ui.info "This could take a while..."
+      end
+
+      dest_path = spec.extension_dir
+      start = Time.now
+
+      spec.extensions.each do |extension|
+        builder_for_ext = if extension[/extconf/]
+                            ExtConfAlwaysCopyBuilder
+                          else
+                            builder.builder_for(extension)
+                          end
+
+        # This throws a Gem::Ext::BuildError if building the extension fails
+        build_extension spec, builder, builder_for_ext, extension, dest_path, build_args
+      end
+      Bundler.ui.info format('  Finished %s after %0.2f seconds', spec.name, Time.now - start)
+      FileUtils.touch(spec.gem_build_complete_path)
+    end
+
+    def build_extension(spec, builder, builder_for_ext, extension, dest_path, build_args) # :nodoc:
+      results = []
+
+      extension_dir =
+        File.expand_path File.join(spec.full_gem_path, File.dirname(extension))
+      lib_dir = File.join spec.full_gem_path, spec.raw_require_paths.first
+
+      begin
+        FileUtils.mkdir_p dest_path
+
+        results = builder_for_ext.build(extension, dest_path,
+                                        results, build_args, lib_dir, extension_dir)
+
+        builder.verbose { results.join("\n") }
+
+        builder.write_gem_make_out results.join "\n"
+      rescue StandardError => e
+        results << e.message
+        builder.build_error(results.join("\n"), $@)
+      end
+    end
+
+    def generate_bin(spec, options = {})
+      gem_dir = Pathname.new(spec.full_gem_path)
+
+      # Some gem authors put absolute paths in their gemspec
+      # and we have to save them from themselves
+      spec.files = spec.files.filter_map do |path|
+        pathname = Pathname.new(path)
+        next path unless pathname.absolute?
+        next if File.directory?(path)
+        begin
+          pathname.relative_path_from(gem_dir).to_s
+        rescue ArgumentError
+          path
+        end
+      end
+
+      installer = Bundler::Source::Path::Installer.new(
+        spec,
+        env_shebang: false,
+        disable_extensions: options[:disable_extensions],
+        build_args: options[:build_args],
+        bundler_extension_cache_path: extension_cache_path(spec)
+      )
+      installer.post_install
+    rescue Gem::InvalidSpecificationException => e
+      Bundler.ui.warn "\n#{spec.name} at #{spec.full_gem_path} did not have a valid gemspec.\n" \
+                      "This prevents bundler from installing bins or native extensions, but " \
+                      "that may not affect its functionality."
+
+      if !spec.extensions.empty? && !spec.email.empty?
+        Bundler.ui.warn "If you need to use this package without installing it from a gem " \
+                        "repository, please contact #{spec.email} and ask them " \
+                        "to modify their .gemspec so it can work with `gem build`."
+      end
+
+      Bundler.ui.warn "The validation message from RubyGems was:\n  #{e.message}"
+    end
+  end
+
+  # Modified version of Gem::Ext::ExtConfBuilder that always copies the built binary
+  # to the destination path. This is necessary because when using local gems we cannot
+  # rely on versions being bumped when the gem changes.
+  class ExtConfAlwaysCopyBuilder < Gem::Ext::Builder
+    def self.build(extension, dest_path, results, args = [], lib_dir = nil, extension_dir = Dir.pwd,
+      target_rbconfig = nil, n_jobs: nil)
+      require "fileutils"
+      require "tempfile"
+
+      target_rbconfig ||= Gem.target_rbconfig if HAS_TARGET_RBCONFIG
+
+      tmp_dest = Dir.mktmpdir(".gem.", extension_dir)
+
+      # Some versions of `mktmpdir` return absolute paths, which will break make
+      # if the paths contain spaces.
+      #
+      # As such, we convert to a relative path.
+      tmp_dest_relative = get_relative_path(tmp_dest.clone, extension_dir)
+
+      destdir = ENV["DESTDIR"]
+
+      begin
+        cmd = ruby << File.basename(extension)
+        cmd << "--target-rbconfig=#{target_rbconfig.path}" if HAS_TARGET_RBCONFIG && target_rbconfig.path
+        cmd.push(*args)
+
+        run(cmd, results, 'ExtConfAlwaysCopy', extension_dir) do |s, r|
+          mkmf_log = File.join(extension_dir, "mkmf.log")
+          if File.exist? mkmf_log
+            unless s.success?
+              r << "To see why this extension failed to compile, please check" \
+                " the mkmf.log which can be found here:\n"
+              r << "  " + File.join(dest_path, "mkmf.log") + "\n"
+            end
+            FileUtils.mv mkmf_log, dest_path
+          end
+        end
+
+        ENV["DESTDIR"] = nil
+
+        if HAS_TARGET_RBCONFIG && HAS_NJOBS
+          make dest_path, results, extension_dir, tmp_dest_relative, target_rbconfig: target_rbconfig, n_jobs: n_jobs
+        elsif HAS_TARGET_RBCONFIG
+          make dest_path, results, extension_dir, tmp_dest_relative, target_rbconfig: target_rbconfig
+        else
+          make dest_path, results, extension_dir, tmp_dest_relative
+        end
+
+        full_tmp_dest = File.join(extension_dir, tmp_dest_relative)
+
+        is_cross_compiling = HAS_TARGET_RBCONFIG && target_rbconfig["platform"] != RbConfig::CONFIG["platform"]
+
+        entries = (Dir.entries(full_tmp_dest) - %w[. ..]).map {|entry| File.join full_tmp_dest, entry }
+
+        # MODIFIED
+        # Rubygems copies the built files into the gem's lib directory, and then
+        # additionally moves them into the extension install directory, but only
+        # the ones that don't exist there yet. We install into a single location,
+        # always overwriting, so a rebuilt extension leaves no stale binary behind.
+        #
+        # Note that install_extension_in_lib can be turned off through gemrc, and
+        # that Rubygems intends to eventually default it to false, which would
+        # make the extension directory the regular case rather than a fallback.
+        #
+        # Rubygems skips the copy into lib when cross-compiling, because that
+        # directory is shared with the build for the host platform, and relies on
+        # the extension install directory being specific to the target (it follows
+        # Gem::Platform.local, which is derived from the target rbconfig). The
+        # directory we use is keyed to the platform of the running Ruby, so we
+        # have nowhere to put a cross-compiled build, and skip it entirely.
+        unless is_cross_compiling
+          if Gem.install_extension_in_lib && lib_dir
+            FileUtils.mkdir_p lib_dir
+            FileUtils.cp_r entries, lib_dir, remove_destination: true
+          else
+            FileUtils.cp_r entries, dest_path, remove_destination: true
+          end
+        end
+
+        if HAS_TARGET_RBCONFIG
+          make dest_path, results, extension_dir, tmp_dest_relative, ["clean"], target_rbconfig: target_rbconfig
+        else
+          make dest_path, results, extension_dir, tmp_dest_relative, ["clean"]
+        end
+      ensure
+        ENV["DESTDIR"] = destdir
+      end
+
+      results
+    rescue => error
+      if defined?(Gem::Ext::Builder::NoMakefileError) && error.is_a?(Gem::Ext::Builder::NoMakefileError)
+        results << error.message
+        results << "Skipping make for #{extension} as no Makefile was found."
+        # We are good, do not re-raise the error.
+      else
+        raise
+      end
+    ensure
+      FileUtils.rm_rf tmp_dest if tmp_dest
+    end
+
+    def self.get_relative_path(path, base)
+      path[0..base.length - 1] = "." if path.start_with?(base)
+      path
+    end
+  end
+end

data/plugins.rb

@@ -1,266 +1,9 @@
-class BundlerSourcePathext < Bundler::Plugin::API
-  HAS_TARGET_RBCONFIG = Gem.rubygems_version >= Gem::Version.new("3.6")
-  HAS_NJOBS = Gem.rubygems_version >= Gem::Version.new("4.0.2")
+# frozen_string_literal: true
 
-  class PathExtSource < Bundler::Source
-    def install(spec, opts)
-      print_using_message "Using #{spec.name} #{spec.version} from #{self}"
+require 'bundler-source-pathext'
 
-      using_message = "Using #{version_message(spec, options[:previous_spec])} from #{self}"
-      using_message += " and installing its executables" unless spec.executables.empty?
-      print_using_message using_message
-      generate_bin(spec, disable_extensions: true) # Turned off!
-
-      build_local_extensions(spec)
-
-      nil # no post-install message
-    end
-
-    # Bundler plugin api, we need to return a Bundler::Index
-    def specs
-      files = Dir.glob(File.join(File.expand_path(uri), '*.gemspec'))
-
-      Bundler::Index.build do |index|
-        files.each do |file|
-          next unless spec = Bundler.load_gemspec(file)
-          spec.installed_by_version = Gem::VERSION
-          spec.source = self
-          spec.extension_dir = File.join(File.dirname(file), 'tmp', RUBY_PLATFORM, spec.name, RUBY_VERSION)
-          Bundler.rubygems.validate(spec)
-
-          index << spec
-        end
-      end
-    end
-
-    # Set internal representation to fetch the gems/specs locally.
-    #
-    # When this is called, the source should try to fetch the specs and
-    # install from the local system.
-    def local!
-      # not applicable
-    end
-
-    # Set internal representation to fetch the gems/specs from remote.
-    #
-    # When this is called, the source should try to fetch the specs and
-    # install from remote path.
-    def remote!
-      # not applicable
-    end
-
-    # Set internal representation to fetch the gems/specs from app cache.
-    #
-    # When this is called, the source should try to fetch the specs and
-    # install from the path provided by `app_cache_path`.
-    def cached!
-      # not applicable
-    end
-
-    # This is called to update the spec and installation.
-    #
-    # If the source plugin is loaded from lockfile or otherwise, it shall
-    # refresh the cache/specs (e.g. git sources can make a fresh clone).
-    def unlock!
-      # not applicable
-    end
-
-    private
-
-    def build_local_extensions(spec)
-      build_args = options[:build_args] || Bundler.rubygems.build_args || begin
-        require_relative "command"
-        Gem::Command.build_args
-      end
-
-      builder = Gem::Ext::Builder.new spec, build_args
-
-      build_extensions(spec, build_args, builder)
-    end
-
-    def build_extensions(spec, build_args, builder)
-      return if spec.extensions.empty?
-
-      if build_args.empty?
-        puts "Building native extensions for #{spec.name}. This could take a while..."
-      else
-        puts "Building native extensions for #{spec.name} with: '#{@build_args.join " "}'"
-        puts "This could take a while..."
-      end
-
-      dest_path = spec.extension_dir
-      start = Time.now
-
-      spec.extensions.each do |extension|
-        builder_for_ext = if extension[/extconf/]
-                            ExtConfAlwaysCopyBuilder
-                          else
-                            builder.builder_for(extension)
-                          end
-
-        # This throws a Gem::Ext::BuildError if building the extension fails
-        build_extension spec, builder, builder_for_ext, extension, dest_path
-      end
-      puts format('  Finished %s after %0.2f seconds', spec.name, Time.now - start)
-      FileUtils.touch(spec.gem_build_complete_path)
-    end
-
-    def build_extension(spec, builder, builder_for_ext, extension, dest_path) # :nodoc:
-      results = []
-
-      extension_dir =
-        File.expand_path File.join(spec.full_gem_path, File.dirname(extension))
-      lib_dir = File.join spec.full_gem_path, spec.raw_require_paths.first
-
-      begin
-        FileUtils.mkdir_p dest_path
-
-        results = builder_for_ext.build(extension, dest_path,
-                                        results, @build_args, lib_dir, extension_dir)
-
-        builder.verbose { results.join("\n") }
-
-        builder.write_gem_make_out results.join "\n"
-      rescue StandardError => e
-        results << e.message
-        builder.build_error(results.join("\n"), $@)
-      end
-    end
-
-    def generate_bin(spec, options = {})
-      gem_dir = Pathname.new(spec.full_gem_path)
-
-      # Some gem authors put absolute paths in their gemspec
-      # and we have to save them from themselves
-      spec.files = spec.files.filter_map do |path|
-        next path unless /\A#{Pathname::SEPARATOR_PAT}/o.match?(path)
-        next if File.directory?(path)
-        begin
-          Pathname.new(path).relative_path_from(gem_dir).to_s
-        rescue ArgumentError
-          path
-        end
-      end
-
-      installer = Path::Installer.new(
-        spec,
-        env_shebang: false,
-        disable_extensions: options[:disable_extensions],
-        build_args: options[:build_args],
-        bundler_extension_cache_path: extension_cache_path(spec)
-      )
-      installer.post_install
-    rescue Gem::InvalidSpecificationException => e
-      Bundler.ui.warn "\n#{spec.name} at #{spec.full_gem_path} did not have a valid gemspec.\n" \
-                      "This prevents bundler from installing bins or native extensions, but " \
-                      "that may not affect its functionality."
-
-      if !spec.extensions.empty? && !spec.email.empty?
-        Bundler.ui.warn "If you need to use this package without installing it from a gem " \
-                        "repository, please contact #{spec.email} and ask them " \
-                        "to modify their .gemspec so it can work with `gem build`."
-      end
-
-      Bundler.ui.warn "The validation message from RubyGems was:\n  #{e.message}"
-    end
-  end
-
-  source 'pathext', PathExtSource
-
-  # Modified version of Gem::Ext::ExtConfBuilder that always copies the built binary
-  # to the destination path. This is necessary because when using local gems we cannot
-  # rely on versions being bumped when the gem changes.
-  require 'rubygems/ext'
-  class ExtConfAlwaysCopyBuilder < Gem::Ext::Builder
-    def self.build(extension, dest_path, results, args = [], lib_dir = nil, extension_dir = Dir.pwd,
-      target_rbconfig = nil, n_jobs: nil)
-      require "fileutils"
-      require "tempfile"
-
-      target_rbconfig ||= Gem.target_rbconfig if HAS_TARGET_RBCONFIG
-
-      tmp_dest = Dir.mktmpdir(".gem.", extension_dir)
-
-      # Some versions of `mktmpdir` return absolute paths, which will break make
-      # if the paths contain spaces.
-      #
-      # As such, we convert to a relative path.
-      tmp_dest_relative = get_relative_path(tmp_dest.clone, extension_dir)
-
-      destdir = ENV["DESTDIR"]
-
-      begin
-        cmd = ruby << File.basename(extension)
-        cmd << "--target-rbconfig=#{target_rbconfig.path}" if HAS_TARGET_RBCONFIG && target_rbconfig.path
-        cmd.push(*args)
-
-        run(cmd, results, 'ExtConfAlwaysCopy', extension_dir) do |s, r|
-          mkmf_log = File.join(extension_dir, "mkmf.log")
-          if File.exist? mkmf_log
-            unless s.success?
-              r << "To see why this extension failed to compile, please check" \
-                " the mkmf.log which can be found here:\n"
-              r << "  " + File.join(dest_path, "mkmf.log") + "\n"
-            end
-            FileUtils.mv mkmf_log, dest_path
-          end
-        end
-
-        ENV["DESTDIR"] = nil
-
-        if HAS_TARGET_RBCONFIG && HAS_NJOBS
-          make dest_path, results, extension_dir, tmp_dest_relative, target_rbconfig: target_rbconfig, n_jobs: n_jobs
-        elsif HAS_TARGET_RBCONFIG
-          make dest_path, results, extension_dir, tmp_dest_relative, target_rbconfig: target_rbconfig
-        else
-          make dest_path, results, extension_dir, tmp_dest_relative
-        end
-
-        full_tmp_dest = File.join(extension_dir, tmp_dest_relative)
-
-        is_cross_compiling = HAS_TARGET_RBCONFIG && target_rbconfig["platform"] != RbConfig::CONFIG["platform"]
-        # Do not copy extension libraries by default when cross-compiling
-        # not to conflict with the one already built for the host platform.
-        if Gem.install_extension_in_lib && lib_dir && !is_cross_compiling
-          FileUtils.mkdir_p lib_dir
-          entries = Dir.entries(full_tmp_dest) - %w[. ..]
-          entries = entries.map {|entry| File.join full_tmp_dest, entry }
-          FileUtils.cp_r entries, lib_dir, remove_destination: true
-        end
-
-        # MODIFIED
-        # We skip installing into the destination directory, because we can rely on the copy in lib/ instead
-        # This also causes caching issues with stale files
-        #FileUtils::Entry_.new(full_tmp_dest).traverse do |ent|
-        #  destent = ent.class.new(dest_path, ent.rel)
-        #  destent.exist? || FileUtils.mv(ent.path, destent.path)
-        #end
-
-        if HAS_TARGET_RBCONFIG
-          make dest_path, results, extension_dir, tmp_dest_relative, ["clean"], target_rbconfig: target_rbconfig
-        else
-          make dest_path, results, extension_dir, tmp_dest_relative, ["clean"]
-        end
-      ensure
-        ENV["DESTDIR"] = destdir
-      end
-
-      results
-    rescue => error
-      if defined?(Gem::Ext::Builder::NoMakefileError) && error.is_a?(Gem::Ext::Builder::NoMakefileError)
-        results << error.message
-        results << "Skipping make for #{extension} as no Makefile was found."
-        # We are good, do not re-raise the error.
-      else
-        raise
-      end
-    ensure
-      FileUtils.rm_rf tmp_dest if tmp_dest
-    end
-
-    def self.get_relative_path(path, base)
-      path[0..base.length - 1] = "." if path.start_with?(base)
-      path
-    end
-  end
-end
+# Note that Bundler loads this file once when the plugin is installed, and again
+# when the plugin is used, and only keeps the sources registered by the latter.
+# The registration therefore has to happen here, and not in the required file,
+# which only gets loaded once per process.
+BundlerSourcePathext.source 'pathext', BundlerSourcePathext::PathExtSource

metadata

@@ -1,22 +1,23 @@
 --- !ruby/object:Gem::Specification
 name: bundler-source-pathext
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - pganalyze Team
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-17 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: ''
+description: Bundler source plugin that works like a path source, but also builds
+  the native extensions of the gems it provides, like a remote gem source does.
 email:
 - team@pganalyze.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/test.yml"
 - ".gitignore"
 - Gemfile
 - Gemfile.lock
@@ -24,11 +25,12 @@ files:
 - README.md
 - Rakefile
 - bundler-source-pathext.gemspec
+- lib/bundler-source-pathext.rb
 - plugins.rb
-homepage:
-licenses: []
+homepage: https://github.com/pganalyze/bundler-path-build-ext
+licenses:
+- BSD-3-Clause
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -36,15 +38,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
-summary: ''
+summary: Bundler source plugin for local gems with native extensions
 test_files: []