scint 0.6.0 → 0.7.1

data/lib/scint/lockfile/writer.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "../spec_utils"
+
 module Scint
   module Lockfile
     # Writes a standard Gemfile.lock file from structured data.
     # Produces output compatible with stock bundler.
     #
     # Sections in order: source blocks (GEM/GIT/PATH), PLATFORMS,
-    # DEPENDENCIES, CHECKSUMS (if present), RUBY VERSION.
+    # DEPENDENCIES, CHECKSUMS (if present), RUBY VERSION, BUNDLED WITH.
     class Writer
       def self.write(lockfile_data)
         new(lockfile_data).generate
@@ -24,6 +26,7 @@ module Scint
         add_dependencies(out)
         add_checksums(out)
         add_ruby_version(out)
+        add_bundled_with(out)
 
         out
       end
@@ -32,67 +35,95 @@ module Scint
 
       def add_sources(out)
         # Group specs by source, preserving source order.
-        # Specs store source as a URI string; sources are Source objects.
-        # Match by checking if the spec's source URI matches any remote.
         specs_by_source = {}
         @data.sources.each { |s| specs_by_source[s] = [] }
 
         @data.specs.each do |spec|
-          spec_src = spec.is_a?(Hash) ? spec[:source] : spec.source
-          spec_uri = normalize_source_uri(spec_src)
-
-          matched = @data.sources.find do |source|
-            if source.respond_to?(:remotes)
-              source.remotes.any? { |r| normalize_source_uri(r) == spec_uri }
-            elsif source.respond_to?(:uri)
-              normalize_source_uri(source.uri) == spec_uri
-            else
-              source == spec_src
-            end
-          end
+          target = match_source_for_spec(spec) || @data.sources.first
+          next unless target
 
-          target = matched || @data.sources.first
           specs_by_source[target] ||= []
           specs_by_source[target] << spec
         end
 
-        first = true
+        emitted = false
         @data.sources.each do |source|
-          out << "\n" unless first
-          first = false
+          source_specs = specs_by_source[source] || []
+          next if source_specs.empty?
+
+          out << "\n" if emitted
+          emitted = true
 
           out << source.to_lock
-          add_specs(out, specs_by_source[source] || [])
+          add_specs(out, source_specs)
         end
       end
 
-      def normalize_source_uri(uri)
-        s = uri.to_s.chomp("/")
-        s.sub(%r{^https?://}, "").downcase
+      def match_source_for_spec(spec)
+        spec_source = spec.is_a?(Hash) ? spec[:source] : spec.source
+        return nil unless spec_source
+
+        @data.sources.find { |source| source_matches?(source, spec_source) }
+      end
+
+      def source_matches?(source, spec_source)
+        return true if source.equal?(spec_source)
+        return true if source == spec_source
+
+        spec_key = normalize_source_key(spec_source)
+        return false unless spec_key
+
+        if source.respond_to?(:remotes)
+          source.remotes.any? { |remote| normalize_source_key(remote) == spec_key }
+        elsif source.respond_to?(:uri)
+          normalize_source_key(source.uri) == spec_key
+        else
+          normalize_source_key(source) == spec_key
+        end
+      end
+
+      def normalize_source_key(source_ref)
+        raw =
+          if source_ref.respond_to?(:uri)
+            source_ref.uri.to_s
+          elsif source_ref.respond_to?(:path)
+            source_ref.path.to_s
+          else
+            source_ref.to_s
+          end
+        return nil if raw.empty?
+
+        if raw.match?(%r{\Ahttps?://}i)
+          raw = raw.sub(%r{\Ahttps?://}i, "")
+          raw = raw.sub(%r{\.git/?\z}i, "")
+          raw.chomp("/").downcase
+        elsif raw.start_with?("/") || raw.start_with?(".")
+          File.expand_path(raw)
+        else
+          raw.sub(%r{\.git/?\z}i, "").chomp("/").downcase
+        end
       end
 
       def add_specs(out, specs)
         # Sort by full name (name-version-platform) for consistency
         sorted = specs.sort_by do |s|
           if s.is_a?(Hash)
-            n = s[:name]
-            v = s[:version]
-            p = s[:platform]
-            p == "ruby" ? "#{n}-#{v}" : "#{n}-#{v}-#{p}"
+            SpecUtils.full_name_for(s[:name], s[:version], s[:platform])
           else
-            "#{s.name}-#{s.version}#{"-#{s.platform}" if s.platform != "ruby"}"
+            SpecUtils.full_name_for(s.name, s.version, s.platform)
           end
         end
 
         sorted.each do |spec|
-          name, version, platform, deps = if spec.is_a?(Hash)
-            [spec[:name], spec[:version], spec[:platform], spec[:dependencies] || []]
+          name, version, deps = if spec.is_a?(Hash)
+            [spec[:name], spec[:version], spec[:dependencies] || []]
           else
-            [spec.name, spec.version, spec.platform, spec.dependencies || []]
+            [spec.name, spec.version, spec.dependencies || []]
           end
 
           # Format: "    name (version)" or "    name (version-platform)"
-          version_str = platform && platform != "ruby" ? "#{version}-#{platform}" : version.to_s
+          platform_str = SpecUtils.platform_str(spec)
+          version_str = platform_str == "ruby" ? version.to_s : "#{version}-#{platform_str}"
           out << "    #{name} (#{version_str})\n"
 
           # Dependencies of this spec (6-space indent)
@@ -152,19 +183,37 @@ module Scint
         return unless @data.checksums
         out << "\nCHECKSUMS\n"
 
-        @data.checksums.sort.each do |key, values|
+        @data.checksums.each do |key, values|
+          rendered_key = format_checksum_key(key)
           if values && !values.empty?
-            out << "  #{key} #{values.join(",")}\n"
+            out << "  #{rendered_key} #{values.join(",")}\n"
           else
-            out << "  #{key}\n"
+            out << "  #{rendered_key}\n"
           end
         end
       end
 
+      def format_checksum_key(key)
+        match = key.to_s.match(/\A(.+)-(\d[^-]*)(?:-(.+))?\z/)
+        return key unless match
+
+        name = match[1]
+        version = match[2]
+        platform = match[3]
+        version_str = platform ? "#{version}-#{platform}" : version
+        "#{name} (#{version_str})"
+      end
+
       def add_ruby_version(out)
         return unless @data.ruby_version
         out << "\nRUBY VERSION\n"
-        out << "  #{@data.ruby_version}\n"
+        out << "   #{@data.ruby_version}\n"
+      end
+
+      def add_bundled_with(out)
+        return unless @data.bundler_version
+        out << "\nBUNDLED WITH\n"
+        out << "   #{@data.bundler_version}\n"
       end
 
     end

data/lib/scint/platform.rb

@@ -40,6 +40,14 @@ module Scint
       RUBY_VERSION
     end
 
+    def ruby_minor_version_dir
+      @ruby_minor_version_dir ||= RUBY_VERSION.split(".")[0, 2].join(".") + ".0"
+    end
+
+    def ruby_install_dir(base)
+      File.join(base, "ruby", ruby_minor_version_dir)
+    end
+
     def extension_api_version
       ::Gem.extension_api_version
     end

data/lib/scint/resolver/provider.rb

@@ -86,7 +86,7 @@ module Scint
             pg = @path_gems[name]
             deps = {}
             (pg[:dependencies] || []).each do |dep_name, dep_req_str|
-              deps[dep_name] = Gem::Requirement.new(dep_req_str || ">= 0")
+              deps[dep_name] = build_requirement(dep_req_str)
             end
             deps
           else
@@ -99,7 +99,7 @@ module Scint
               next unless requirements_match?(reqs)
               dep_hash.each do |dep_name, dep_req_str|
                 # Merge constraints from all matching platform entries
-                req = Gem::Requirement.new(dep_req_str.split(", "))
+                req = build_requirement(dep_req_str)
                 deps[dep_name] = if deps[dep_name]
                   merge_requirements(deps[dep_name], req)
                 else
@@ -276,6 +276,19 @@ module Scint
 
         Gem::Requirement.new(filtered.map { |op, version| "#{op} #{version}" })
       end
+
+      def build_requirement(value)
+        case value
+        when Gem::Requirement
+          value
+        when Array
+          parts = value.flatten.compact.map(&:to_s).reject(&:empty?)
+          Gem::Requirement.new(*(parts.empty? ? [">= 0"] : parts))
+        else
+          parts = value.to_s.split(",").map(&:strip).reject(&:empty?)
+          Gem::Requirement.new(*(parts.empty? ? [">= 0"] : parts))
+        end
+      end
     end
   end
 end

data/lib/scint/runtime/exec.rb

@@ -2,8 +2,10 @@
 
 require_relative "setup"
 require_relative "../fs"
+require_relative "../platform"
 require "base64"
 require "pathname"
+require "rbconfig"
 
 module Scint
   module Runtime
@@ -19,40 +21,40 @@ module Scint
       # lock_path: path to .bundle/scint.lock.marshal
       def exec(command, args, lock_path)
         original_env = ENV.to_hash
-        lock_data = Setup.load_lock(lock_path)
+        Setup.load_lock(lock_path)
+        command, args = rewrite_bundle_exec(command, args)
+        passthrough_bundle = bundle_command?(command)
 
         bundle_dir = File.dirname(lock_path)
         scint_lib_dir = File.expand_path("../..", __dir__)
-        ruby_dir = File.join(bundle_dir, "ruby",
-                             RUBY_VERSION.split(".")[0, 2].join(".") + ".0")
-
-        # Collect all load paths from the runtime config
-        paths = []
-        lock_data.each_value do |info|
-          Array(info[:load_paths]).each do |p|
-            paths << p if File.directory?(p)
-          end
+        ruby_dir = Platform.ruby_install_dir(bundle_dir)
+
+        # Set RUBYLIB to make our Bundler shim loadable. We intentionally avoid
+        # injecting all gem load paths here because large apps can exceed exec
+        # argument/environment limits when RUBYLIB gets too long.
+        # Gem load paths are still activated via Scint::Runtime::Setup from
+        # `-rbundler/setup`.
+        unless passthrough_bundle
+          existing = ENV["RUBYLIB"]
+          rubylib = scint_lib_dir
+          rubylib = "#{rubylib}#{File::PATH_SEPARATOR}#{existing}" if existing && !existing.empty?
+          ENV["RUBYLIB"] = rubylib
         end
 
-        # Ensure our bundler shim wins over global bundler.
-        # Order matters: scint lib first, then gem load paths.
-        paths.unshift(scint_lib_dir)
-
-        # Set RUBYLIB so the child process inherits load paths.
-        existing = ENV["RUBYLIB"]
-        rubylib = paths.join(File::PATH_SEPARATOR)
-        rubylib = "#{rubylib}#{File::PATH_SEPARATOR}#{existing}" if existing && !existing.empty?
-        ENV["RUBYLIB"] = rubylib
-
         ENV["SCINT_RUNTIME_LOCK"] = lock_path
         ENV["GEM_HOME"] = ruby_dir
-        ENV["GEM_PATH"] = ruby_dir
+        ENV["GEM_PATH"] = build_gem_path(ruby_dir, original_env["GEM_PATH"])
         ENV["BUNDLE_PATH"] = bundle_dir
         ENV["BUNDLE_APP_CONFIG"] = bundle_dir
         ENV["BUNDLE_GEMFILE"] = find_gemfile(bundle_dir)
-        ENV["PATH"] = prepend_path(File.join(ruby_dir, "bin"), ENV["PATH"])
+        ruby_interpreter_bin = File.dirname(RbConfig.ruby)
+
+        # Keep interpreter/bin ahead of .bundle/bin so `#!/usr/bin/env ruby`
+        # resolves to the interpreter, not a gem-provided "ruby" executable.
         ENV["PATH"] = prepend_path(File.join(bundle_dir, "bin"), ENV["PATH"])
-        prepend_rubyopt("-rbundler/setup")
+        ENV["PATH"] = prepend_path(File.join(ruby_dir, "bin"), ENV["PATH"])
+        ENV["PATH"] = prepend_path(ruby_interpreter_bin, ENV["PATH"])
+        prepend_rubyopt("-rbundler/setup") unless passthrough_bundle
         export_original_env(original_env)
 
         command = resolve_command(command, bundle_dir, ruby_dir)
@@ -76,9 +78,9 @@ module Scint
 
       def prepend_path(prefix, current_path)
         return prefix unless current_path && !current_path.empty?
-        return current_path if current_path.split(File::PATH_SEPARATOR).include?(prefix)
-
-        "#{prefix}#{File::PATH_SEPARATOR}#{current_path}"
+        parts = current_path.split(File::PATH_SEPARATOR).reject(&:empty?)
+        parts.delete(prefix)
+        ([prefix] + parts).join(File::PATH_SEPARATOR)
       end
 
       def export_original_env(original_env)
@@ -87,6 +89,29 @@ module Scint
         # Non-fatal: shim can fallback to current ENV.
       end
 
+      def build_gem_path(bundle_ruby_dir, original_gem_path)
+        paths = [bundle_ruby_dir]
+        if defined?(Gem) && Gem.respond_to?(:default_path)
+          paths.concat(Array(Gem.default_path))
+        end
+        if original_gem_path && !original_gem_path.empty?
+          paths.concat(original_gem_path.split(File::PATH_SEPARATOR))
+        end
+        paths.reject(&:empty?).uniq.join(File::PATH_SEPARATOR)
+      end
+
+      def bundle_command?(command)
+        File.basename(command.to_s) == "bundle"
+      end
+
+      def rewrite_bundle_exec(command, args)
+        return [command, args] unless bundle_command?(command)
+        return [command, args] unless args.first == "exec"
+        return [command, args] if args.length < 2
+
+        [args[1], args[2..] || []]
+      end
+
       def resolve_command(command, bundle_dir, ruby_dir)
         return command if command.include?(File::SEPARATOR)
 
@@ -135,6 +160,7 @@ module Scint
       end
 
       private_class_method :find_gemfile, :prepend_rubyopt, :prepend_path, :export_original_env,
+                           :bundle_command?, :rewrite_bundle_exec, :build_gem_path,
                            :resolve_command, :find_gem_executable, :write_bundle_exec_wrapper
     end
   end

data/lib/scint/runtime/setup.rb

@@ -29,6 +29,7 @@ module Scint
         $LOAD_PATH.unshift(*paths)
 
         ENV["BUNDLE_GEMFILE"] ||= find_gemfile(File.dirname(lock_path))
+        hydrate_loaded_specs(lock_data)
 
         lock_data
       end
@@ -39,7 +40,34 @@ module Scint
         File.exist?(gemfile) ? gemfile : nil
       end
 
-      private_class_method :find_gemfile
+      def hydrate_loaded_specs(lock_data)
+        return unless defined?(Gem) && Gem.respond_to?(:loaded_specs)
+
+        lock_data.each do |name, info|
+          gem_name = name.to_s
+          next if gem_name.empty? || Gem.loaded_specs[gem_name]
+
+          version = info.is_a?(Hash) ? info[:version] : nil
+          spec = find_installed_spec(gem_name, version)
+          Gem.loaded_specs[gem_name] = spec if spec
+        end
+      rescue StandardError
+        # Best-effort compatibility with gems expecting Gem.loaded_specs.
+      end
+
+      def find_installed_spec(gem_name, version)
+        version_req = version.to_s.strip
+        if !version_req.empty?
+          exact = Gem::Specification.find_all_by_name(gem_name, version_req)
+          return exact.find { |spec| spec.version.to_s == version_req } || exact.first
+        end
+
+        Gem::Specification.find_all_by_name(gem_name).max_by(&:version)
+      rescue StandardError
+        nil
+      end
+
+      private_class_method :find_gemfile, :hydrate_loaded_specs, :find_installed_spec
     end
   end
 end

data/lib/scint/scheduler.rb

@@ -329,7 +329,12 @@ module Scint
           job.error = error
           @failed[job.id] = job
           @errors << { job_id: job.id, type: job.type, name: job.name, error: error }
-          @aborted = true if @fail_fast
+          if @fail_fast
+            @aborted = true
+            # Drop queued work immediately; wait_all will return once current
+            # in-flight jobs drain.
+            @pending.clear
+          end
         else
           job.state = :completed
           @completed[job.id] = job

data/lib/scint/spec_utils.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+require "open3"
+require "rbconfig"
+
+module Scint
+  module SpecUtils
+    module_function
+
+    GEMSPEC_LOAD_MUTEX = Thread::Mutex.new
+
+    GEMSPEC_SUBPROCESS_LOADER = <<~'RUBY'
+      path = ARGV.fetch(0)
+      begin
+        Dir.chdir(File.dirname(path)) do
+          spec = Gem::Specification.load(path)
+          exit(2) unless spec
+          STDOUT.binmode
+          STDOUT.write(Marshal.dump(spec))
+        end
+      rescue Exception => e
+        warn("#{e.class}: #{e.message}")
+        exit(1)
+      end
+    RUBY
+
+    def name(spec)
+      spec.respond_to?(:name) ? spec.name : spec[:name]
+    end
+
+    def version(spec)
+      spec.respond_to?(:version) ? spec.version : spec[:version]
+    end
+
+    def platform(spec)
+      return spec.platform if spec.respond_to?(:platform)
+      return spec[:platform] if spec.is_a?(Hash)
+      return nil unless spec.respond_to?(:[])
+
+      spec[:platform]
+    rescue NameError, ArgumentError
+      nil
+    end
+
+    def platform_str(spec)
+      platform_value(platform(spec))
+    end
+
+    def platform_value(platform)
+      value = platform.nil? ? "ruby" : platform.to_s
+      value.empty? ? "ruby" : value
+    end
+
+    def full_name(spec)
+      base = "#{name(spec)}-#{version(spec)}"
+      plat = platform_str(spec)
+      return base if plat == "ruby"
+
+      "#{base}-#{plat}"
+    end
+
+    def full_name_for(name, version, platform = "ruby")
+      base = "#{name}-#{version}"
+      plat = platform_value(platform)
+      return base if plat == "ruby"
+
+      "#{base}-#{plat}"
+    end
+
+    def full_key(spec)
+      full_key_for(name(spec), version(spec), platform(spec))
+    end
+
+    def full_key_for(name, version, platform = "ruby")
+      "#{name}-#{version}-#{platform_value(platform)}"
+    end
+
+    # Load a gemspec with path-sensitive fallback.
+    #
+    # Some gemspecs depend on process cwd (e.g. `require "./lib/..."`,
+    # `File.read("README")`). A direct load can fail when evaluated from a
+    # different working directory. For those failures, evaluate in a dedicated
+    # subprocess that can safely chdir without affecting install worker threads.
+    def load_gemspec(path, isolate: false)
+      absolute = File.expand_path(path.to_s)
+      return nil unless File.file?(absolute)
+      return load_gemspec_in_subprocess(absolute) if isolate
+
+      spec = load_gemspec_direct(absolute)
+      return spec if spec
+
+      load_gemspec_in_subprocess(absolute)
+    rescue StandardError, ScriptError => e
+      return load_gemspec_in_subprocess(absolute) if gemspec_path_context_error?(e)
+
+      nil
+    end
+
+    def gemspec_path_context_error?(error)
+      return true if error.is_a?(LoadError)
+      return true if error.is_a?(Errno::ENOENT)
+
+      message = error.message.to_s
+      message.include?("conflicting chdir during another chdir block") ||
+        message.include?("cannot load such file -- ./") ||
+        message.include?("cannot load such file -- ../")
+    end
+    private_class_method :gemspec_path_context_error?
+
+    def load_gemspec_direct(absolute_path)
+      GEMSPEC_LOAD_MUTEX.synchronize do
+        ::Gem::Specification.load(absolute_path)
+      end
+    end
+    private_class_method :load_gemspec_direct
+
+    def load_gemspec_in_subprocess(absolute_path)
+      out, _err, status = Open3.capture3(
+        RbConfig.ruby,
+        "-rrubygems",
+        "-e",
+        GEMSPEC_SUBPROCESS_LOADER,
+        absolute_path,
+      )
+      return nil unless status.success?
+      return nil if out.nil? || out.empty?
+
+      Marshal.load(out)
+    rescue StandardError
+      nil
+    end
+    private_class_method :load_gemspec_in_subprocess
+  end
+end

data/lib/scint.rb

@@ -59,6 +59,7 @@ module Scint
   autoload :Progress,    "scint/progress"
   autoload :FS,          "scint/fs"
   autoload :Platform,    "scint/platform"
+  autoload :SpecUtils,   "scint/spec_utils"
 
   # Errors
   autoload :BundlerError,        "scint/errors"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scint
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Tobi Lutke
@@ -27,8 +27,10 @@ files:
 - lib/bundler/setup.rb
 - lib/scint.rb
 - lib/scint/cache/layout.rb
+- lib/scint/cache/manifest.rb
 - lib/scint/cache/metadata_store.rb
 - lib/scint/cache/prewarm.rb
+- lib/scint/cache/validity.rb
 - lib/scint/cli.rb
 - lib/scint/cli/add.rb
 - lib/scint/cli/cache.rb
@@ -56,6 +58,8 @@ files:
 - lib/scint/installer/linker.rb
 - lib/scint/installer/planner.rb
 - lib/scint/installer/preparer.rb
+- lib/scint/installer/promoter.rb
+- lib/scint/linker.sh
 - lib/scint/lockfile/parser.rb
 - lib/scint/lockfile/writer.rb
 - lib/scint/platform.rb
@@ -69,6 +73,7 @@ files:
 - lib/scint/source/git.rb
 - lib/scint/source/path.rb
 - lib/scint/source/rubygems.rb
+- lib/scint/spec_utils.rb
 - lib/scint/vendor/pub_grub.rb
 - lib/scint/vendor/pub_grub/assignment.rb
 - lib/scint/vendor/pub_grub/basic_package_source.rb