scint 0.1.0

data/lib/scint/resolver/provider.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module Scint
+  module Resolver
+    # Bridges compact index data and the PubGrub resolver.
+    # Converts compact index info entries into version lists and dependency hashes.
+    #
+    # Supports multiple sources: each gem can be routed to a specific
+    # Index::Client based on source_map (gem_name => source_uri).
+    class Provider
+      # default_client: Index::Client for the default source (rubygems.org)
+      # clients: hash { source_uri_string => Index::Client } for all sources
+      # source_map: hash { gem_name => source_uri_string } for gems with explicit sources
+      # path_gems: hash { gem_name => { version:, dependencies: } } for path/git gems
+      # locked_specs: hash { name => version_string } for locked version preferences
+      # platforms: array of platform strings to match against
+      def initialize(default_client, clients: {}, source_map: {}, path_gems: {},
+                     locked_specs: {}, platforms: nil)
+        @default_client = default_client
+        @clients = clients
+        @source_map = source_map
+        @path_gems = path_gems
+        @locked_specs = locked_specs
+        @platforms = platforms || default_platforms
+        @versions_cache = {}
+        @deps_cache = {}
+        @info_cache = {}
+        @mutex = Thread::Mutex.new
+      end
+
+      # For backward compat and use in resolver (e.g. source_uri on resolved specs)
+      def index_client
+        @default_client
+      end
+
+      # Returns the source URI for a gem name.
+      def source_uri_for(name)
+        if @path_gems.key?(name)
+          @path_gems[name][:source] || "path"
+        elsif @source_map.key?(name)
+          @source_map[name]
+        else
+          @default_client.source_uri
+        end
+      end
+
+      # Returns the Index::Client for a given gem name.
+      def client_for(name)
+        source_uri = @source_map[name]
+        if source_uri
+          @clients[source_uri] || @default_client
+        else
+          @default_client
+        end
+      end
+
+      # Returns sorted array of Gem::Version for a given gem name,
+      # filtered to matching platforms.
+      def versions_for(name)
+        @versions_cache[name] ||= begin
+          # Path/git gems: return the single known version
+          if @path_gems.key?(name)
+            pg = @path_gems[name]
+            [Gem::Version.new(pg[:version] || "0")]
+          else
+            entries = info_for(name)
+            versions = {}
+            entries.each do |_name, version, platform, _deps, _reqs|
+              next unless platform_match?(platform)
+              ver = Gem::Version.new(version)
+              versions[version] ||= ver
+            end
+            versions.values.sort
+          end
+        end
+      end
+
+      # Returns dependency hash for a specific gem name + version.
+      # { "dep_name" => Gem::Requirement, ... }
+      def dependencies_for(name, version)
+        key = "#{name}-#{version}"
+        @deps_cache[key] ||= begin
+          # Path/git gems: return their declared dependencies
+          if @path_gems.key?(name)
+            pg = @path_gems[name]
+            deps = {}
+            (pg[:dependencies] || []).each do |dep_name, dep_req_str|
+              deps[dep_name] = Gem::Requirement.new(dep_req_str || ">= 0")
+            end
+            deps
+          else
+            version_str = version.to_s
+            entries = info_for(name)
+            deps = {}
+
+            entries.each do |_name, ver, platform, dep_hash, _reqs|
+              next unless ver == version_str && platform_match?(platform)
+              dep_hash.each do |dep_name, dep_req_str|
+                # Merge constraints from all matching platform entries
+                req = Gem::Requirement.new(dep_req_str.split(", "))
+                deps[dep_name] = if deps[dep_name]
+                  merge_requirements(deps[dep_name], req)
+                else
+                  req
+                end
+              end
+            end
+
+            deps
+          end
+        end
+      end
+
+      # Check if a gem version has native extensions.
+      # Approximated by checking if there's a platform-specific variant.
+      def has_extensions?(name, version)
+        return false if @path_gems.key?(name)
+
+        version_str = version.to_s
+        entries = info_for(name)
+        has_platform_specific = false
+        entries.each do |_name, ver, platform, _deps, _reqs|
+          next unless ver == version_str
+          has_platform_specific = true if platform != "ruby"
+        end
+        has_platform_specific
+      end
+
+      # Choose the most appropriate platform for a resolved version,
+      # preferring local binary gems over ruby source gems when available.
+      def preferred_platform_for(name, version)
+        return "ruby" if @path_gems.key?(name)
+
+        version_str = version.to_s
+        entries = info_for(name).select do |_n, ver, platform, _deps, _reqs|
+          ver == version_str && platform_match?(platform)
+        end
+        return "ruby" if entries.empty?
+
+        local_platforms = @platforms.reject { |p| p == "ruby" }
+        non_ruby = entries.map { |e| e[2] }.compact.reject { |p| p == "ruby" }.uniq
+
+        preferred = nil
+        best_score = nil
+        non_ruby.each do |platform|
+          local_platforms.each_with_index do |local, index|
+            spec_plat = platform.is_a?(Gem::Platform) ? platform : Gem::Platform.new(platform)
+            local_plat = local.is_a?(Gem::Platform) ? local : Gem::Platform.new(local)
+            next unless spec_plat === local_plat
+
+            exact = spec_plat.to_s == local_plat.to_s ? 1 : 0
+            score = [exact, -index]
+            next if best_score && score <= best_score
+
+            best_score = score
+            preferred = platform
+          end
+        end
+        return preferred if preferred
+
+        entries.any? { |e| e[2] == "ruby" } ? "ruby" : entries.first[2].to_s
+      end
+
+      # Returns the locked version for a gem, if any.
+      def locked_version(name)
+        v = @locked_specs[name]
+        v ? Gem::Version.new(v) : nil
+      end
+
+      # Prefetch info for a batch of gem names, routing to the correct client.
+      def prefetch(names)
+        # Filter to names we haven't cached yet, skip path/git gems
+        uncached = names.reject { |n| @info_cache.key?(n) || @path_gems.key?(n) }
+        return if uncached.empty?
+
+        # Group by client
+        by_client = Hash.new { |h, k| h[k] = [] }
+        uncached.each do |name|
+          by_client[client_for(name)] << name
+        end
+
+        by_client.each do |client, client_names|
+          results = client.prefetch(client_names)
+          next unless results
+
+          @mutex.synchronize do
+            results.each do |name, data|
+              @info_cache[name] = data
+            end
+          end
+        end
+      end
+
+      # Returns true if the gem is a path or git source gem.
+      def path_or_git_gem?(name)
+        @path_gems.key?(name)
+      end
+
+      private
+
+      def info_for(name)
+        @info_cache[name] ||= client_for(name).fetch_info(name)
+      end
+
+      def default_platforms
+        local = Platform.local_platform.to_s
+        platforms = ["ruby"]
+        platforms << local unless local == "ruby"
+        platforms
+      end
+
+      def platform_match?(spec_platform)
+        return true if spec_platform.nil? || spec_platform == "ruby"
+        spec_plat = spec_platform.is_a?(Gem::Platform) ? spec_platform : Gem::Platform.new(spec_platform)
+        @platforms.any? do |plat|
+          next false if plat == "ruby"
+
+          local_plat = plat.is_a?(Gem::Platform) ? plat : Gem::Platform.new(plat)
+          spec_plat === local_plat
+        end
+      end
+
+      def merge_requirements(req1, req2)
+        # Combine requirement constraints
+        combined = req1.requirements + req2.requirements
+        Gem::Requirement.new(combined.map { |op, v| "#{op} #{v}" })
+      end
+    end
+  end
+end

data/lib/scint/resolver/resolver.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require_relative "../vendor/pub_grub"
+require_relative "provider"
+
+module Scint
+  module Resolver
+    # ResolvedSpec: the output of resolution.
+    ResolvedSpec = Struct.new(
+      :name, :version, :platform, :dependencies,
+      :source, :has_extensions, :remote_uri, :checksum,
+      keyword_init: true
+    )
+
+    # PubGrub-based dependency resolver.
+    # Implements the source interface that PubGrub::VersionSolver expects.
+    class Resolver
+      attr_reader :provider
+
+      # provider: Resolver::Provider instance
+      # dependencies: array of Gemfile::Dependency (top-level requirements)
+      # locked_specs: hash { name => version_string } for preferring locked versions
+      def initialize(provider:, dependencies:, locked_specs: {})
+        @provider = provider
+        @dependencies = dependencies
+        @locked_specs = locked_specs
+        @packages = {}  # name => PubGrub::Package
+
+        @root_package = Scint::PubGrub::Package.root
+        @root_version = Scint::PubGrub::Package.root_version
+
+        # MUST be ascending — PubGrub uses binary search in select_versions.
+        @sorted_versions = Hash.new do |h, k|
+          if k == @root_package
+            h[k] = [@root_version]
+          else
+            h[k] = all_versions_for(k).sort
+          end
+        end
+
+        @cached_dependencies = Hash.new do |packages, package|
+          if package == @root_package
+            packages[package] = { @root_version => root_dependencies }
+          else
+            packages[package] = Hash.new do |versions, version|
+              versions[version] = dependencies_for(package, version)
+            end
+          end
+        end
+      end
+
+      # Run resolution. Returns array of ResolvedSpec.
+      def resolve
+        # Prefetch all known gem info before resolution
+        prefetch_all
+
+        solver = Scint::PubGrub::VersionSolver.new(
+          source: self,
+          root: @root_package,
+          logger: NullLogger.new
+        )
+
+        result = solver.solve
+
+        result.filter_map do |package, version|
+          next if Scint::PubGrub::Package.root?(package)
+          build_resolved_spec(package, version)
+        end
+      end
+
+      # --- PubGrub source interface ---
+
+      def versions_for(package, range = Scint::PubGrub::VersionRange.any)
+        range.select_versions(@sorted_versions[package])
+      end
+
+      def incompatibilities_for(package, version)
+        package_deps = @cached_dependencies[package]
+        sorted_versions = @sorted_versions[package]
+        package_deps[version].map do |dep_package, dep_constraint|
+          low = high = sorted_versions.index(version)
+
+          # find version low such that all >= low share the same dep
+          while low > 0 && package_deps[sorted_versions[low - 1]][dep_package] == dep_constraint
+            low -= 1
+          end
+          low = low == 0 ? nil : sorted_versions[low]
+
+          # find version high such that all < high share the same dep
+          while high < sorted_versions.length && package_deps[sorted_versions[high]][dep_package] == dep_constraint
+            high += 1
+          end
+          high = high == sorted_versions.length ? nil : sorted_versions[high]
+
+          range = Scint::PubGrub::VersionRange.new(min: low, max: high, include_min: !low.nil?)
+          self_constraint = Scint::PubGrub::VersionConstraint.new(package, range: range)
+
+          dep_term = Scint::PubGrub::Term.new(dep_constraint, false)
+          self_term = Scint::PubGrub::Term.new(self_constraint, true)
+
+          Scint::PubGrub::Incompatibility.new([self_term, dep_term], cause: :dependency)
+        end
+      end
+
+      def no_versions_incompatibility_for(_package, unsatisfied_term)
+        cause = Scint::PubGrub::Incompatibility::NoVersions.new(unsatisfied_term)
+        Scint::PubGrub::Incompatibility.new([unsatisfied_term], cause: cause)
+      end
+
+      # Public: PubGrub Strategy calls this to build version preference index.
+      # Returns newest-first so index 0 = newest = most preferred.
+      # Locked versions are promoted to the front (most preferred).
+      def all_versions_for(package)
+        name = package.name
+        versions = @provider.versions_for(name).reverse  # newest first
+
+        locked = @locked_specs[name]
+        if locked
+          locked_ver = Gem::Version.new(locked)
+          # Move locked version to front if present
+          if (idx = versions.index(locked_ver))
+            versions.delete_at(idx)
+            versions.unshift(locked_ver)
+          end
+        end
+
+        versions
+      end
+
+      private
+
+      def package_for(name)
+        @packages[name] ||= Scint::PubGrub::Package.new(name)
+      end
+
+      def root_dependencies
+        deps = {}
+        @dependencies.each do |dep|
+          pkg = package_for(dep.name)
+          req = Gem::Requirement.new(dep.version_reqs)
+          range = requirement_to_range(req)
+          constraint = Scint::PubGrub::VersionConstraint.new(pkg, range: range)
+
+          deps[pkg] = if deps[pkg]
+            deps[pkg].intersect(constraint)
+          else
+            constraint
+          end
+        end
+        deps
+      end
+
+      def dependencies_for(package, version)
+        name = package.name
+        dep_hash = @provider.dependencies_for(name, version)
+        result = {}
+
+        dep_hash.each do |dep_name, dep_req|
+          dep_package = package_for(dep_name)
+          range = requirement_to_range(dep_req)
+          constraint = Scint::PubGrub::VersionConstraint.new(dep_package, range: range)
+          result[dep_package] = constraint
+        end
+
+        result
+      end
+
+      def requirement_to_range(requirement)
+        ranges = requirement.requirements.map do |(op, version)|
+          case op
+          when "~>"
+            name = "~> #{version}"
+            bump = Gem::Version.new(version.bump.to_s + ".A")
+            Scint::PubGrub::VersionRange.new(name: name, min: version, max: bump, include_min: true)
+          when ">"
+            Scint::PubGrub::VersionRange.new(min: version)
+          when ">="
+            Scint::PubGrub::VersionRange.new(min: version, include_min: true)
+          when "<"
+            Scint::PubGrub::VersionRange.new(max: version)
+          when "<="
+            Scint::PubGrub::VersionRange.new(max: version, include_max: true)
+          when "="
+            Scint::PubGrub::VersionRange.new(min: version, max: version, include_min: true, include_max: true)
+          when "!="
+            Scint::PubGrub::VersionRange.new(min: version, max: version, include_min: true, include_max: true).invert
+          else
+            raise ResolveError, "bad version specifier: #{op}"
+          end
+        end
+
+        ranges.inject(&:intersect)
+      end
+
+      # Prefetch compact index info for all known gem names.
+      def prefetch_all
+        names = Set.new
+        @dependencies.each { |d| names << d.name }
+
+        # Also include locked spec names and their transitive deps
+        @locked_specs.each_key { |n| names << n }
+
+        # Fetch versions for each unique client (populates checksums).
+        # Skip path/git gems -- they don't use the compact index.
+        fetched_clients = Set.new
+        names.each do |name|
+          next if @provider.path_or_git_gem?(name)
+          client = @provider.client_for(name)
+          unless fetched_clients.include?(client.source_uri)
+            client.fetch_versions
+            fetched_clients << client.source_uri
+          end
+        end
+
+        # Prefetch all info in parallel (provider routes to correct client)
+        @provider.prefetch(names.to_a)
+      end
+
+      def build_resolved_spec(package, version)
+        name = package.name
+        deps = @provider.dependencies_for(name, version)
+        dep_list = deps.map { |n, r| { name: n, version_reqs: [r.to_s] } }
+        platform = @provider.preferred_platform_for(name, version)
+
+        source = @provider.source_uri_for(name)
+
+        Scint::ResolvedSpec.new(
+          name: name,
+          version: version.to_s,
+          platform: platform,
+          dependencies: dep_list,
+          source: source,
+          has_extensions: (platform == "ruby") && @provider.has_extensions?(name, version),
+          remote_uri: nil,
+          checksum: nil,
+        )
+      end
+
+      # Minimal logger that discards output (PubGrub requires a logger).
+      class NullLogger
+        def info(&block) = nil
+        def debug(&block) = nil
+        def warn(&block) = nil
+        def error(&block) = nil
+        def level=(v); end
+      end
+    end
+  end
+end

data/lib/scint/runtime/exec.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+require_relative "../fs"
+require "base64"
+require "pathname"
+
+module Scint
+  module Runtime
+    module Exec
+      module_function
+
+      # Execute a command with the bundled environment.
+      # Reads Marshal'd runtime config, sets RUBYLIB so the child process
+      # has all gem load paths, then Kernel.exec replaces the process.
+      #
+      # command: the program to run (e.g. "rails")
+      # args:    array of arguments
+      # 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)
+
+        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
+        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["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"])
+        ENV["PATH"] = prepend_path(File.join(bundle_dir, "bin"), ENV["PATH"])
+        prepend_rubyopt("-rbundler/setup")
+        export_original_env(original_env)
+
+        command = resolve_command(command, bundle_dir, ruby_dir)
+
+        # Kernel.exec replaces the process
+        Kernel.exec(command, *args)
+      end
+
+      def find_gemfile(bundle_dir)
+        project_root = File.dirname(bundle_dir)
+        gemfile = File.join(project_root, "Gemfile")
+        File.exist?(gemfile) ? gemfile : nil
+      end
+
+      def prepend_rubyopt(flag)
+        parts = ENV["RUBYOPT"].to_s.split(/\s+/).reject(&:empty?)
+        return if parts.include?(flag)
+
+        ENV["RUBYOPT"] = ([flag] + parts).join(" ")
+      end
+
+      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}"
+      end
+
+      def export_original_env(original_env)
+        ENV["SCINT_ORIGINAL_ENV"] ||= Base64.strict_encode64(Marshal.dump(original_env))
+      rescue StandardError
+        # Non-fatal: shim can fallback to current ENV.
+      end
+
+      def resolve_command(command, bundle_dir, ruby_dir)
+        return command if command.include?(File::SEPARATOR)
+
+        bundle_bin = File.join(bundle_dir, "bin")
+        ruby_bin = File.join(ruby_dir, "bin")
+        FS.mkdir_p(bundle_bin)
+
+        bundle_candidate = File.join(bundle_bin, command)
+        return bundle_candidate if File.executable?(bundle_candidate)
+
+        ruby_candidate = File.join(ruby_bin, command)
+        return ruby_candidate if File.executable?(ruby_candidate)
+
+        gem_exec = find_gem_executable(ruby_dir, command)
+        return command unless gem_exec
+
+        write_bundle_exec_wrapper(bundle_candidate, gem_exec, bundle_bin)
+        bundle_candidate
+      end
+
+      def find_gem_executable(ruby_dir, command)
+        gems_dir = File.join(ruby_dir, "gems")
+        return nil unless Dir.exist?(gems_dir)
+
+        Dir.glob(File.join(gems_dir, "*")).sort.each do |gem_dir|
+          %w[exe bin].each do |subdir|
+            candidate = File.join(gem_dir, subdir, command)
+            return candidate if File.file?(candidate)
+          end
+        end
+
+        nil
+      end
+
+      def write_bundle_exec_wrapper(wrapper_path, target_path, bundle_bin)
+        relative = Pathname.new(target_path).relative_path_from(Pathname.new(bundle_bin)).to_s
+        content = <<~RUBY
+          #!/usr/bin/env ruby
+          # frozen_string_literal: true
+          load File.expand_path("#{relative}", __dir__)
+        RUBY
+        FS.atomic_write(wrapper_path, content)
+        File.chmod(0o755, wrapper_path)
+      rescue StandardError
+        # If wrapper creation fails, we'll still fall back to PATH lookup.
+      end
+
+      private_class_method :find_gemfile, :prepend_rubyopt, :prepend_path, :export_original_env,
+                           :resolve_command, :find_gem_executable, :write_bundle_exec_wrapper
+    end
+  end
+end

data/lib/scint/runtime/setup.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Scint
+  module Runtime
+    module Setup
+      module_function
+
+      # Load and return the Marshal'd lock data without modifying $LOAD_PATH.
+      def load_lock(lock_path)
+        unless File.exist?(lock_path)
+          raise LoadError, "Runtime lock not found: #{lock_path}. Run `scint install` first."
+        end
+
+        Marshal.load(File.binread(lock_path)) # rubocop:disable Security/MarshalLoad
+      end
+
+      # Set up $LOAD_PATH from a Marshal'd lock data file.
+      # This is the fast path for in-process setup — <10ms.
+      def setup(lock_path)
+        lock_data = load_lock(lock_path)
+
+        paths = []
+        lock_data.each_value do |info|
+          Array(info[:load_paths]).each do |p|
+            paths << p if File.directory?(p)
+          end
+        end
+
+        $LOAD_PATH.unshift(*paths)
+
+        ENV["BUNDLE_GEMFILE"] ||= find_gemfile(File.dirname(lock_path))
+
+        lock_data
+      end
+
+      def find_gemfile(bundle_dir)
+        project_root = File.dirname(bundle_dir)
+        gemfile = File.join(project_root, "Gemfile")
+        File.exist?(gemfile) ? gemfile : nil
+      end
+
+      private_class_method :find_gemfile
+    end
+  end
+end