scint 0.6.0 → 0.7.1

data/lib/scint/gemfile/parser.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require_relative "dependency"
+require_relative "../source/path"
 
 module Scint
   module Gemfile
     # Result of parsing a Gemfile.
-    ParseResult = Struct.new(:dependencies, :sources, :ruby_version, :platforms, keyword_init: true)
+    ParseResult = Struct.new(:dependencies, :sources, :ruby_version, :platforms, :optional_groups, keyword_init: true)
 
     # Evaluates a Gemfile using instance_eval, just like stock bundler.
     # Supports the full Gemfile DSL: source, gem, group, platforms, git_source,
@@ -19,14 +20,16 @@ module Scint
           sources: parser.parsed_sources.uniq,
           ruby_version: parser.parsed_ruby_version,
           platforms: parser.parsed_platforms,
+          optional_groups: parser.parsed_optional_groups,
         )
       end
 
       # Accessors that don't collide with DSL method names
-      def parsed_dependencies;  @dependencies;  end
-      def parsed_sources;       @sources;       end
-      def parsed_ruby_version;  @ruby_version;  end
-      def parsed_platforms;     @declared_platforms; end
+      def parsed_dependencies;    @dependencies;      end
+      def parsed_sources;         @sources;           end
+      def parsed_ruby_version;    @ruby_version;      end
+      def parsed_platforms;       @declared_platforms; end
+      def parsed_optional_groups; @optional_groups;   end
 
       def initialize(gemfile_path)
         @gemfile_path = File.expand_path(gemfile_path)
@@ -38,6 +41,7 @@ module Scint
         @current_source_options = {}
         @ruby_version = nil
         @declared_platforms = []
+        @optional_groups = []
 
         add_default_git_sources
       end
@@ -134,6 +138,11 @@ module Scint
           source_opts[:path] = path_val
         end
 
+        # Internal/source metadata used by lockfile generation.
+        source_opts[:glob] = options.delete(:glob) if options.key?(:glob)
+        source_opts[:gemspec_generated] = options.delete(:gemspec_generated) if options.key?(:gemspec_generated)
+        source_opts[:gemspec_primary] = options.delete(:gemspec_primary) if options.key?(:gemspec_primary)
+
         if options[:source]
           source_opts[:source] = options.delete(:source)
         end
@@ -161,7 +170,11 @@ module Scint
 
       def group(*names, **opts, &blk)
         old_groups = @current_groups.dup
-        @current_groups.concat(names.map(&:to_sym))
+        group_syms = names.map(&:to_sym)
+        @current_groups.concat(group_syms)
+        if opts[:optional]
+          group_syms.each { |g| @optional_groups << g unless @optional_groups.include?(g) }
+        end
         yield
       ensure
         @current_groups = old_groups
@@ -213,24 +226,39 @@ module Scint
         instance_eval(contents, expanded, 1)
       end
 
-      def ruby(version, **opts)
-        @ruby_version = version.to_s
+      def ruby(*versions, **opts)
+        version_parts = versions.flatten.compact.map(&:to_s)
+        @ruby_version = version_parts.join(", ") unless version_parts.empty?
       end
 
       def gemspec(opts = {})
         path = opts[:path] || "."
         name = opts[:name]
+        glob = opts[:glob] || Scint::Source::Path::DEFAULT_GLOB
         dir = File.expand_path(path, File.dirname(@gemfile_path))
-        gemspecs = Dir.glob(File.join(dir, "{,*}.gemspec"))
+        gemspecs = Dir.glob(File.join(dir, glob)).sort
         # Just record we have a gemspec source -- full spec loading is
         # deferred to the resolver/installer.
         gemspecs.each do |gs|
           spec_name = File.basename(gs, ".gemspec")
           next if name && spec_name != name
-          gem(spec_name, path: dir)
+          gem(
+            spec_name,
+            path: File.dirname(gs),
+            glob: glob,
+            gemspec_generated: true,
+            gemspec_primary: File.expand_path(File.dirname(gs)) == dir,
+          )
         end
       end
 
+      def install_if(*conditions, &blk)
+        raise GemfileError, "install_if requires a block" unless block_given?
+        return unless conditions.all? { |condition| condition_truthy?(condition) }
+
+        yield
+      end
+
       # Silently ignore plugin declarations
       def plugin(*args); end
 
@@ -247,6 +275,12 @@ module Scint
 
       private
 
+      def condition_truthy?(condition)
+        return condition.call if condition.respond_to?(:call)
+
+        !!condition
+      end
+
       def add_default_git_sources
         git_source(:github) do |repo_name|
           if repo_name =~ %r{\Ahttps://github\.com/([^/]+/[^/]+)/pull/(\d+)\z}

data/lib/scint/installer/extension_builder.rb

@@ -3,6 +3,7 @@
 require_relative "../fs"
 require_relative "../platform"
 require_relative "../errors"
+require_relative "../spec_utils"
 require "open3"
 
 module Scint
@@ -10,65 +11,63 @@ module Scint
     module ExtensionBuilder
       module_function
 
+      BUILD_MARKER = ".scint.build_complete"
+
       # Build native extensions for a prepared gem.
       # prepared_gem: PreparedGem struct
       # bundle_path:  .bundle/ root
       # abi_key:      e.g. "ruby-3.3.0-arm64-darwin24" (defaults to Platform.abi_key)
       def build(prepared_gem, bundle_path, cache_layout, abi_key: Platform.abi_key, compile_slots: 1, output_tail: nil)
         spec = prepared_gem.spec
-        ruby_dir = ruby_install_dir(bundle_path)
         build_ruby_dir = cache_layout.install_ruby_dir
-
-        # Check global extension cache first
-        cached_ext = cache_layout.ext_path(spec, abi_key)
-        if Dir.exist?(cached_ext) && File.exist?(File.join(cached_ext, "gem.build_complete"))
-          link_extensions(cached_ext, ruby_dir, spec, abi_key)
-          return true
-        end
-
-        # Build in a temp dir, then cache
         src_dir = prepared_gem.extracted_path
-        ext_dirs = find_extension_dirs(src_dir)
-        raise ExtensionBuildError, "No extension directories found for #{spec.name}" if ext_dirs.empty?
 
+        marker = build_marker_path(src_dir)
+        return true if File.exist?(marker)
+
+        # Build in a temp dir, then sync artifacts into the source tree.
         FS.with_tempdir("scint-ext") do |tmpdir|
-          build_dir = File.join(tmpdir, "build")
+          # Stage the full gem source tree in an isolated workspace.
+          # Many extconf scripts use paths like ../../vendor relative to ext/,
+          # which only work when the full gem layout is preserved.
+          staged_src_dir = File.join(tmpdir, "source")
+          FS.clone_tree(src_dir, staged_src_dir)
+
+          ext_dirs = find_extension_dirs(staged_src_dir)
+          raise ExtensionBuildError, "No extension directories found for #{spec.name}" if ext_dirs.empty?
+
+          build_root = File.join(tmpdir, "build")
           install_dir = File.join(tmpdir, "install")
-          FS.mkdir_p(build_dir)
+          FS.mkdir_p(build_root)
           FS.mkdir_p(install_dir)
 
-          ext_dirs.each do |ext_dir|
-            compile_extension(ext_dir, build_dir, install_dir, src_dir, spec, build_ruby_dir, compile_slots, output_tail)
+          ext_dirs.each_with_index do |ext_dir, idx|
+            # Keep isolated build trees per extension directory. Some gems
+            # invoke multiple CMake projects under ext/ and CMake caches are
+            # source-tree specific.
+            ext_build_dir = File.join(build_root, idx.to_s)
+            FS.mkdir_p(ext_build_dir)
+            compile_extension(ext_dir, ext_build_dir, install_dir, staged_src_dir, spec, build_ruby_dir, compile_slots, output_tail)
           end
 
-          # Write marker
-          File.write(File.join(install_dir, "gem.build_complete"), "")
-
-          # Cache globally
-          FS.mkdir_p(File.dirname(cached_ext))
-          FS.atomic_move(install_dir, cached_ext)
+          sync_extensions_into_gem(install_dir, src_dir)
         end
 
-        link_extensions(cached_ext, ruby_dir, spec, abi_key)
+        File.write(marker, "")
         true
       end
 
       # True when a completed global extension build exists for this spec + ABI.
       def cached_build_available?(spec, cache_layout, abi_key: Platform.abi_key)
-        cached_ext = cache_layout.ext_path(spec, abi_key)
-        Dir.exist?(cached_ext) && File.exist?(File.join(cached_ext, "gem.build_complete"))
+        cached_dir = cache_layout.cached_path(spec, abi_key)
+        File.exist?(build_marker_path(cached_dir))
       end
 
-      # Link already-compiled extensions from global cache into bundle_path.
-      # Returns true when cache was present and linked, false otherwise.
-      def link_cached_build(prepared_gem, bundle_path, cache_layout, abi_key: Platform.abi_key)
+      # Link already-compiled extensions from the cached gem tree.
+      # Returns true when cache marker is present, false otherwise.
+      def link_cached_build(prepared_gem, _bundle_path, cache_layout, abi_key: Platform.abi_key)
         spec = prepared_gem.spec
-        return false unless cached_build_available?(spec, cache_layout, abi_key: abi_key)
-
-        ruby_dir = ruby_install_dir(bundle_path)
-        cached_ext = cache_layout.ext_path(spec, abi_key)
-        link_extensions(cached_ext, ruby_dir, spec, abi_key)
-        true
+        cached_build_available?(spec, cache_layout, abi_key: abi_key)
       end
 
       # True when a gem has native extension sources that need compiling.
@@ -120,9 +119,18 @@ module Scint
           dirs << File.dirname(path)
         end
 
-        # CMakeLists.txt in ext/
-        Dir.glob(File.join(gem_dir, "ext", "**", "CMakeLists.txt")).each do |path|
-          dir = File.dirname(path)
+        # CMakeLists.txt in ext/. Keep only top-level CMake roots, so vendored
+        # subprojects (e.g. deps/*) are not built standalone.
+        cmake_dirs = Dir.glob(File.join(gem_dir, "ext", "**", "CMakeLists.txt"))
+                        .map { |path| File.dirname(path) }
+                        .uniq
+                        .sort_by { |dir| [dir.length, dir] }
+        cmake_roots = []
+        cmake_dirs.each do |dir|
+          next if cmake_roots.any? { |root| dir.start_with?("#{root}/") }
+          cmake_roots << dir
+        end
+        cmake_roots.each do |dir|
           dirs << dir unless dirs.include?(dir)
         end
 
@@ -141,7 +149,7 @@ module Scint
         env = build_env(gem_dir, build_ruby_dir, make_jobs)
 
         if File.exist?(File.join(ext_dir, "extconf.rb"))
-          compile_extconf(ext_dir, build_dir, install_dir, env, make_jobs, output_tail)
+          compile_extconf(ext_dir, gem_dir, build_dir, install_dir, env, make_jobs, output_tail)
         elsif File.exist?(File.join(ext_dir, "CMakeLists.txt"))
           compile_cmake(ext_dir, build_dir, install_dir, env, make_jobs, output_tail)
         elsif File.exist?(File.join(ext_dir, "Rakefile"))
@@ -151,13 +159,18 @@ module Scint
         end
       end
 
-      def compile_extconf(ext_dir, build_dir, install_dir, env, make_jobs, output_tail = nil)
+      def compile_extconf(ext_dir, gem_dir, build_dir, install_dir, env, make_jobs, output_tail = nil)
+        # Build in-place within the staged ext directory so extconf scripts
+        # that navigate relative paths (../../vendor, ../..) behave like
+        # Bundler's install layout.
+        _ = gem_dir
+        _ = build_dir
         run_cmd(env, RbConfig.ruby, File.join(ext_dir, "extconf.rb"),
                 "--with-opt-dir=#{RbConfig::CONFIG["prefix"]}",
-                chdir: build_dir, output_tail: output_tail)
-        run_cmd(env, "make", "-j#{make_jobs}", "-C", build_dir, output_tail: output_tail)
+                chdir: ext_dir, output_tail: output_tail)
+        run_cmd(env, "make", "-j#{make_jobs}", "-C", ext_dir, output_tail: output_tail)
         run_cmd(env, "make", "install", "DESTDIR=", "sitearchdir=#{install_dir}", "sitelibdir=#{install_dir}",
-                chdir: build_dir, output_tail: output_tail)
+                chdir: ext_dir, output_tail: output_tail)
       end
 
       def compile_cmake(ext_dir, build_dir, install_dir, env, make_jobs, output_tail = nil)
@@ -208,9 +221,28 @@ module Scint
         ext_install_dir = File.join(ruby_dir, "extensions",
                                     Platform.gem_arch, Platform.extension_api_version,
                                     spec_full_name(spec))
-        return if Dir.exist?(ext_install_dir)
+        FS.clone_tree(cached_ext, ext_install_dir) unless Dir.exist?(ext_install_dir)
+        gem_dir = File.join(ruby_dir, "gems", spec_full_name(spec))
+        sync_extensions_into_gem(cached_ext, gem_dir)
+      end
 
-        FS.clone_tree(cached_ext, ext_install_dir)
+      # Sync compiled extension artifacts into a gem's lib directory.
+      # source_dir should contain the compiled artifacts (from build output
+      # or a cached gem tree).
+      def sync_extensions_into_gem(cached_ext, gem_dir)
+        lib_dir = File.join(gem_dir, "lib")
+        FS.mkdir_p(lib_dir)
+
+        Dir.glob(File.join(cached_ext, "**", "*.{so,bundle,dll,dylib}")).each do |artifact|
+          rel = artifact.delete_prefix("#{cached_ext}/")
+          dest = File.join(lib_dir, rel)
+          FS.mkdir_p(File.dirname(dest))
+          FS.clonefile(artifact, dest)
+        end
+      end
+
+      def build_marker_path(gem_dir)
+        File.join(gem_dir, BUILD_MARKER)
       end
 
       def build_env(gem_dir, build_ruby_dir, make_jobs)
@@ -254,6 +286,7 @@ module Scint
 
         Open3.popen2e(env, *cmd, **opts) do |stdin, out_err, wait_thr|
           stdin.close
+          out_err.set_encoding("ASCII-8BIT")
 
           out_err.each_line do |line|
             stripped = line.rstrip
@@ -279,21 +312,13 @@ module Scint
       end
 
       def spec_full_name(spec)
-        name = spec.name
-        version = spec.version
-        plat = spec.respond_to?(:platform) ? spec.platform : nil
-        base = "#{name}-#{version}"
-        (plat.nil? || plat.to_s == "ruby" || plat.to_s.empty?) ? base : "#{base}-#{plat}"
-      end
-
-      def ruby_install_dir(bundle_path)
-        File.join(bundle_path, "ruby", RUBY_VERSION.split(".")[0, 2].join(".") + ".0")
+        SpecUtils.full_name(spec)
       end
 
       private_class_method :find_extension_dirs, :compile_extension,
                            :compile_extconf, :compile_cmake, :compile_rake,
-                           :find_rake_executable, :link_extensions, :build_env, :run_cmd,
-                           :spec_full_name, :ruby_install_dir, :prebuilt_missing_for_ruby?
+                           :find_rake_executable, :link_extensions,
+                           :build_env, :run_cmd, :prebuilt_missing_for_ruby?
     end
   end
 end

data/lib/scint/installer/linker.rb

@@ -2,6 +2,9 @@
 
 require_relative "../fs"
 require_relative "../platform"
+require_relative "../spec_utils"
+require_relative "../cache/layout"
+require_relative "../cache/validity"
 require "pathname"
 
 module Scint
@@ -20,7 +23,7 @@ module Scint
       # Link gem files + gemspec only (no binstubs).
       # This allows binstubs to be scheduled as a separate DAG task.
       def link_files(prepared_gem, bundle_path)
-        ruby_dir = ruby_install_dir(bundle_path)
+        ruby_dir = Platform.ruby_install_dir(bundle_path)
         link_files_to_ruby_dir(prepared_gem, ruby_dir)
       end
 
@@ -28,12 +31,12 @@ module Scint
       # This is used for the install-time hermetic build environment.
       def link_files_to_ruby_dir(prepared_gem, ruby_dir)
         spec = prepared_gem.spec
-        full_name = spec_full_name(spec)
+        full_name = SpecUtils.full_name(spec)
 
         # 1. Link gem files into gems/{full_name}/
         gem_dest = File.join(ruby_dir, "gems", full_name)
         unless Dir.exist?(gem_dest)
-          FS.clone_tree(prepared_gem.extracted_path, gem_dest)
+          materialize_gem_dir(prepared_gem, gem_dest)
         end
 
         # 2. Write gemspec into specifications/
@@ -42,9 +45,9 @@ module Scint
 
       # Write binstubs for one already-linked gem.
       def write_binstubs(prepared_gem, bundle_path)
-        ruby_dir = ruby_install_dir(bundle_path)
+        ruby_dir = Platform.ruby_install_dir(bundle_path)
         spec = prepared_gem.spec
-        full_name = spec_full_name(spec)
+        full_name = SpecUtils.full_name(spec)
         gem_dest = File.join(ruby_dir, "gems", full_name)
         return unless Dir.exist?(gem_dest)
 
@@ -59,6 +62,44 @@ module Scint
 
       # --- private helpers ---
 
+      def materialize_gem_dir(prepared_gem, gem_dest)
+        manifest = cached_manifest_for(prepared_gem)
+        if manifest && manifest["files"].is_a?(Array)
+          FS.materialize_from_manifest(prepared_gem.extracted_path, gem_dest, manifest["files"])
+        else
+          FS.clone_tree(prepared_gem.extracted_path, gem_dest)
+        end
+      end
+
+      def cached_manifest_for(prepared_gem)
+        return nil unless prepared_gem.from_cache
+
+        layout = cache_layout_for(prepared_gem)
+        cached_path = layout.cached_path(prepared_gem.spec)
+        return nil unless File.expand_path(prepared_gem.extracted_path) == File.expand_path(cached_path)
+
+        manifest = Cache::Validity.read_manifest(layout.cached_manifest_path(prepared_gem.spec))
+        return nil unless manifest
+        return nil unless Cache::Validity.manifest_matches?(manifest, prepared_gem.spec, Platform.abi_key, layout)
+
+        manifest
+      rescue StandardError
+        nil
+      end
+
+      def cache_layout_for(prepared_gem)
+        extracted = File.expand_path(prepared_gem.extracted_path)
+        abi_dir = File.dirname(extracted)
+        cached_dir = File.dirname(abi_dir)
+        root = File.dirname(cached_dir)
+
+        if File.basename(abi_dir) == Platform.abi_key && File.basename(cached_dir) == "cached"
+          Cache::Layout.new(root: root)
+        else
+          Cache::Layout.new
+        end
+      end
+
       def write_gemspec(prepared_gem, ruby_dir, full_name)
         spec_dir = File.join(ruby_dir, "specifications")
         FS.mkdir_p(spec_dir)
@@ -101,7 +142,7 @@ module Scint
           #!/usr/bin/env ruby
           # frozen_string_literal: true
           #
-          # This file was generated by scint for #{spec_full_name(spec)}
+          # This file was generated by scint for #{SpecUtils.full_name(spec)}
           #
           gem "#{spec.name}", "#{spec.version}"
           load Gem.bin_path("#{spec.name}", "#{exe_name}", "#{spec.version}")
@@ -193,34 +234,18 @@ module Scint
           Gem::Specification.new do |s|
             s.name = #{spec.name.inspect}
             s.version = #{spec.version.to_s.inspect}
-            s.platform = #{platform_str(spec).inspect}
+            s.platform = #{SpecUtils.platform_str(spec).inspect}
             s.authors = ["scint"]
             s.summary = "Installed by scint"
           end
         RUBY
       end
 
-      def spec_full_name(spec)
-        name = spec.name
-        version = spec.version
-        plat = platform_str(spec)
-        base = "#{name}-#{version}"
-        (plat == "ruby" || plat.empty?) ? base : "#{base}-#{plat}"
-      end
-
-      def platform_str(spec)
-        p = spec.respond_to?(:platform) ? spec.platform : nil
-        p.nil? ? "ruby" : p.to_s
-      end
-
-      def ruby_install_dir(bundle_path)
-        File.join(bundle_path, "ruby", RUBY_VERSION.split(".")[0, 2].join(".") + ".0")
-      end
-
-      private_class_method :write_gemspec, :write_binstubs_impl, :write_ruby_bin_stub,
+      private_class_method :materialize_gem_dir, :cached_manifest_for, :cache_layout_for,
+                           :write_gemspec, :write_binstubs_impl, :write_ruby_bin_stub,
                            :write_bundle_bin_wrapper, :extract_executables,
                            :detect_executables_from_files, :augment_executable_metadata, :infer_bindir,
-                           :minimal_gemspec, :spec_full_name, :platform_str, :ruby_install_dir
+                           :minimal_gemspec
     end
   end
 end

data/lib/scint/installer/planner.rb

@@ -2,25 +2,27 @@
 
 require_relative "extension_builder"
 require_relative "../platform"
+require_relative "../cache/validity"
 
 module Scint
   module Installer
     module Planner
       module_function
+      PATH_GLOB_DEFAULT = "{,*,*/*}.gemspec"
 
       # Compare resolved specs against what's already installed.
       # Returns an Array of PlanEntry with action set to one of:
       #   :skip      — already installed in bundle_path
-      #   :link      — extracted in global cache, just needs linking
+      #   :link      — cached in global cache, just needs linking
       #   :download  — needs downloading from remote
       #   :build_ext — has native extensions that need compiling
       #
       # Download entries are sorted largest-first so big gems start early,
       # keeping the pipeline saturated while small gems fill in gaps.
-      def plan(resolved_specs, bundle_path, cache_layout)
-        ruby_dir = ruby_install_dir(bundle_path)
+      def plan(resolved_specs, bundle_path, cache_layout, telemetry: nil)
+        ruby_dir = Platform.ruby_install_dir(bundle_path)
         entries = resolved_specs.map do |spec|
-          plan_one(spec, ruby_dir, cache_layout)
+          plan_one(spec, ruby_dir, cache_layout, telemetry: telemetry)
         end
 
         # Keep built-ins first, then downloads (big->small), then the rest.
@@ -31,7 +33,7 @@ module Scint
         builtins + downloads + rest
       end
 
-      def plan_one(spec, ruby_dir, cache_layout)
+      def plan_one(spec, ruby_dir, cache_layout, telemetry: nil)
         full = cache_layout.full_name(spec)
         gem_path = File.join(ruby_dir, "gems", full)
         spec_path = File.join(ruby_dir, "specifications", "#{full}.gemspec")
@@ -47,10 +49,12 @@ module Scint
 
         # Already installed? Require both gem files and specification.
         if Dir.exist?(gem_path) && File.exist?(spec_path)
-          if extension_link_missing?(spec, ruby_dir, cache_layout)
-            extracted = cache_layout.extracted_path(spec)
+          cache_source = Cache::Validity.source_path_for(spec, cache_layout, telemetry: telemetry)
+          if extension_link_missing?(spec, ruby_dir, cache_layout, cache_source)
             action = ExtensionBuilder.cached_build_available?(spec, cache_layout) ? :link : :build_ext
-            return PlanEntry.new(spec: spec, action: action, cached_path: extracted, gem_path: gem_path)
+            return PlanEntry.new(spec: spec, action: action, cached_path: cache_source, gem_path: gem_path) if cache_source
+
+            return PlanEntry.new(spec: spec, action: :download, cached_path: nil, gem_path: gem_path)
           end
 
           return PlanEntry.new(spec: spec, action: :skip, cached_path: nil, gem_path: gem_path)
@@ -63,43 +67,32 @@ module Scint
           return PlanEntry.new(spec: spec, action: action, cached_path: local_source, gem_path: gem_path)
         end
 
-        # Extracted in global cache?
-        extracted = cache_layout.extracted_path(spec)
-        if Dir.exist?(extracted)
-          action = needs_ext_build?(spec, cache_layout) ? :build_ext : :link
-          return PlanEntry.new(spec: spec, action: action, cached_path: extracted, gem_path: gem_path)
+        cache_source = Cache::Validity.source_path_for(spec, cache_layout, telemetry: telemetry)
+        if cache_source
+          action = needs_ext_build?(spec, cache_layout, cache_source) ? :build_ext : :link
+          return PlanEntry.new(spec: spec, action: action, cached_path: cache_source, gem_path: gem_path)
         end
 
         # Needs downloading
         PlanEntry.new(spec: spec, action: :download, cached_path: nil, gem_path: gem_path)
       end
 
-      def needs_ext_build?(spec, cache_layout)
-        extracted = cache_layout.extracted_path(spec)
-        return false unless ExtensionBuilder.needs_build?(spec, extracted)
+      def needs_ext_build?(spec, cache_layout, source_dir)
+        return false unless source_dir
+        return false unless ExtensionBuilder.needs_build?(spec, source_dir)
 
         !ExtensionBuilder.cached_build_available?(spec, cache_layout)
       end
 
-      def extension_link_missing?(spec, ruby_dir, cache_layout)
-        extracted = cache_layout.extracted_path(spec)
-        return false unless Dir.exist?(extracted)
-        return false unless ExtensionBuilder.needs_build?(spec, extracted)
+      def extension_link_missing?(spec, ruby_dir, cache_layout, source_dir)
+        return false unless source_dir
+        return false unless ExtensionBuilder.needs_build?(spec, source_dir)
 
         full = cache_layout.full_name(spec)
-        ext_install_dir = File.join(
-          ruby_dir,
-          "extensions",
-          Platform.gem_arch,
-          Platform.extension_api_version,
-          full,
-        )
-
-        !Dir.exist?(ext_install_dir)
-      end
+        gem_dir = File.join(ruby_dir, "gems", full)
+        marker = File.join(gem_dir, ExtensionBuilder::BUILD_MARKER)
 
-      def ruby_install_dir(bundle_path)
-        File.join(bundle_path, "ruby", RUBY_VERSION.split(".")[0, 2].join(".") + ".0")
+        !File.exist?(marker)
       end
 
       # Rough size estimate for download ordering.
@@ -131,11 +124,37 @@ module Scint
         return nil if source_str.end_with?(".git") || source_str.include?(".git/")
 
         absolute = File.expand_path(source_str, Dir.pwd)
-        Dir.exist?(absolute) ? absolute : nil
+        return nil unless Dir.exist?(absolute)
+
+        spec_name =
+          if spec.respond_to?(:name)
+            spec.name.to_s
+          else
+            spec[:name].to_s
+          end
+        return absolute if spec_name.empty?
+        return absolute if File.exist?(File.join(absolute, "#{spec_name}.gemspec"))
+
+        glob =
+          if source.respond_to?(:glob) && !source.glob.to_s.empty?
+            source.glob.to_s
+          else
+            PATH_GLOB_DEFAULT
+          end
+
+        Dir.glob(File.join(absolute, glob)).each do |path|
+          return File.dirname(path) if File.basename(path, ".gemspec") == spec_name
+        end
+
+        Dir.glob(File.join(absolute, "**", "*.gemspec")).each do |path|
+          return File.dirname(path) if File.basename(path, ".gemspec") == spec_name
+        end
+
+        absolute
       end
 
       private_class_method :plan_one, :needs_ext_build?, :extension_link_missing?,
-                           :ruby_install_dir, :estimated_size, :local_source_path
+                           :estimated_size, :local_source_path
     end
   end
 end