scint 0.1.0

data/lib/scint/installer/linker.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require_relative "../fs"
+require_relative "../platform"
+require "pathname"
+
+module Scint
+  module Installer
+    module Linker
+      module_function
+
+      # Link a single extracted gem into .bundle/ruby/{version}/
+      # prepared_gem: PreparedGem struct (spec, extracted_path, gemspec, from_cache)
+      # bundle_path:  root .bundle/ directory
+      def link(prepared_gem, bundle_path)
+        link_files(prepared_gem, bundle_path)
+        write_binstubs(prepared_gem, bundle_path)
+      end
+
+      # 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)
+        link_files_to_ruby_dir(prepared_gem, ruby_dir)
+      end
+
+      # Link gem files + gemspec into an explicit ruby gem home directory.
+      # 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)
+
+        # 1. Link gem files into gems/{full_name}/
+        gem_dest = File.join(ruby_dir, "gems", full_name)
+        unless Dir.exist?(gem_dest)
+          FS.hardlink_tree(prepared_gem.extracted_path, gem_dest)
+        end
+
+        # 2. Write gemspec into specifications/
+        write_gemspec(prepared_gem, ruby_dir, full_name)
+      end
+
+      # Write binstubs for one already-linked gem.
+      def write_binstubs(prepared_gem, bundle_path)
+        ruby_dir = ruby_install_dir(bundle_path)
+        spec = prepared_gem.spec
+        full_name = spec_full_name(spec)
+        gem_dest = File.join(ruby_dir, "gems", full_name)
+        return unless Dir.exist?(gem_dest)
+
+        # 3. Create binstubs for executables
+        write_binstubs_impl(prepared_gem, bundle_path, ruby_dir, gem_dest)
+      end
+
+      # Link multiple gems. Thread-safe — each link is independent.
+      def link_batch(prepared_gems, bundle_path)
+        prepared_gems.each { |pg| link(pg, bundle_path) }
+      end
+
+      # --- private helpers ---
+
+      def write_gemspec(prepared_gem, ruby_dir, full_name)
+        spec_dir = File.join(ruby_dir, "specifications")
+        FS.mkdir_p(spec_dir)
+        spec_path = File.join(spec_dir, "#{full_name}.gemspec")
+        return if File.exist?(spec_path)
+
+        content = if prepared_gem.gemspec.is_a?(String)
+                    prepared_gem.gemspec
+                  elsif prepared_gem.gemspec.respond_to?(:to_ruby)
+                    augment_executable_metadata(prepared_gem.gemspec, prepared_gem.extracted_path).to_ruby
+                  else
+                    minimal_gemspec(prepared_gem.spec, full_name)
+                  end
+
+        FS.atomic_write(spec_path, content)
+      end
+
+      def write_binstubs_impl(prepared_gem, bundle_path, ruby_dir, gem_dir)
+        # Look for executables declared in the gemspec
+        executables = extract_executables(prepared_gem, gem_dir)
+        return if executables.empty?
+
+        ruby_bin_dir = File.join(ruby_dir, "bin")
+        bundle_bin_dir = File.join(bundle_path, "bin")
+        FS.mkdir_p(ruby_bin_dir)
+        FS.mkdir_p(bundle_bin_dir)
+
+        executables.each do |exe_name|
+          write_ruby_bin_stub(prepared_gem, ruby_bin_dir, exe_name)
+          write_bundle_bin_wrapper(bundle_path, ruby_bin_dir, bundle_bin_dir, exe_name)
+        end
+      end
+
+      def write_ruby_bin_stub(prepared_gem, ruby_bin_dir, exe_name)
+        binstub_path = File.join(ruby_bin_dir, exe_name)
+        return if File.exist?(binstub_path)
+
+        spec = prepared_gem.spec
+        content = <<~RUBY
+          #!/usr/bin/env ruby
+          # frozen_string_literal: true
+          #
+          # This file was generated by scint for #{spec_full_name(spec)}
+          #
+          gem "#{spec.name}", "#{spec.version}"
+          load Gem.bin_path("#{spec.name}", "#{exe_name}", "#{spec.version}")
+        RUBY
+
+        FS.atomic_write(binstub_path, content)
+        File.chmod(0o755, binstub_path)
+      end
+
+      def write_bundle_bin_wrapper(bundle_path, ruby_bin_dir, bundle_bin_dir, exe_name)
+        wrapper_path = File.join(bundle_bin_dir, exe_name)
+        return if File.exist?(wrapper_path)
+
+        target = File.join(ruby_bin_dir, exe_name)
+        relative_target = Pathname.new(target).relative_path_from(Pathname.new(bundle_bin_dir)).to_s
+        content = <<~RUBY
+          #!/usr/bin/env ruby
+          # frozen_string_literal: true
+          exec(File.expand_path("#{relative_target}", __dir__), *ARGV)
+        RUBY
+
+        FS.atomic_write(wrapper_path, content)
+        File.chmod(0o755, wrapper_path)
+      end
+
+      def extract_executables(prepared_gem, gem_dir)
+        gemspec = prepared_gem.gemspec
+        executables = if gemspec.respond_to?(:executables)
+          Array(gemspec.executables)
+        elsif gemspec.is_a?(Hash) && gemspec[:executables]
+          Array(gemspec[:executables])
+        else
+          []
+        end
+
+        if executables.empty?
+          executables = detect_executables_from_files(gem_dir)
+        end
+
+        executables.map(&:to_s).reject(&:empty?).uniq
+      end
+
+      def detect_executables_from_files(gem_dir)
+        names = []
+        %w[exe bin].each do |subdir|
+          dir = File.join(gem_dir, subdir)
+          next unless Dir.exist?(dir)
+
+          Dir.children(dir).each do |entry|
+            next if entry.start_with?(".")
+            path = File.join(dir, entry)
+            names << entry if File.file?(path)
+          end
+        end
+        names
+      end
+
+      def augment_executable_metadata(gemspec, gem_dir)
+        detected = detect_executables_from_files(gem_dir)
+        return gemspec if detected.empty?
+
+        executables = Array(gemspec.executables).map(&:to_s).reject(&:empty?)
+        bindir = gemspec.respond_to?(:bindir) ? gemspec.bindir.to_s : ""
+
+        selected = executables.empty? ? detected : executables
+        inferred_bindir = infer_bindir(gem_dir, selected, bindir)
+        needs_execs = executables.empty?
+        needs_bindir = !inferred_bindir.nil? && inferred_bindir != bindir
+        return gemspec unless needs_execs || needs_bindir
+
+        patched = gemspec.dup
+        patched.executables = selected if needs_execs
+        patched.bindir = inferred_bindir if needs_bindir
+        patched
+      end
+
+      def infer_bindir(gem_dir, executables, current_bindir)
+        %w[exe bin].each do |dir|
+          next unless executables.all? { |exe| File.file?(File.join(gem_dir, dir, exe)) }
+          return dir
+        end
+
+        current_bindir unless current_bindir.empty?
+      end
+
+      def minimal_gemspec(spec, full_name)
+        <<~RUBY
+          # frozen_string_literal: true
+          Gem::Specification.new do |s|
+            s.name = #{spec.name.inspect}
+            s.version = #{spec.version.to_s.inspect}
+            s.platform = #{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,
+                           :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
+    end
+  end
+end

data/lib/scint/installer/planner.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative "extension_builder"
+require_relative "../platform"
+
+module Scint
+  module Installer
+    module Planner
+      module_function
+
+      # 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
+      #   :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)
+        entries = resolved_specs.map do |spec|
+          plan_one(spec, ruby_dir, cache_layout)
+        end
+
+        # Stable partition: downloads first (big→small), then everything else
+        downloads, rest = entries.partition { |e| e.action == :download }
+        downloads.sort_by! { |e| -(estimated_size(e.spec)) }
+
+        downloads + rest
+      end
+
+      def plan_one(spec, ruby_dir, cache_layout)
+        full = cache_layout.full_name(spec)
+        gem_path = File.join(ruby_dir, "gems", full)
+        spec_path = File.join(ruby_dir, "specifications", "#{full}.gemspec")
+
+        # Built-in gems (scint itself): copy from our own lib tree.
+        if spec.name == "scint" && spec.source.to_s.include?("built-in")
+          if Dir.exist?(gem_path) && File.exist?(spec_path)
+            return PlanEntry.new(spec: spec, action: :skip, cached_path: nil, gem_path: gem_path)
+          end
+
+          return PlanEntry.new(spec: spec, action: :builtin, cached_path: nil, gem_path: gem_path)
+        end
+
+        # 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)
+            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)
+          end
+
+          return PlanEntry.new(spec: spec, action: :skip, cached_path: nil, gem_path: gem_path)
+        end
+
+        # Local path sources are linked directly from their source tree.
+        local_source = local_source_path(spec)
+        if local_source
+          action = ExtensionBuilder.buildable_source_dir?(local_source) ? :build_ext : :link
+          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)
+        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.buildable_source_dir?(extracted)
+
+        !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.buildable_source_dir?(extracted)
+
+        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
+
+      def ruby_install_dir(bundle_path)
+        File.join(bundle_path, "ruby", RUBY_VERSION.split(".")[0, 2].join(".") + ".0")
+      end
+
+      # Rough size estimate for download ordering.
+      # If we don't know, use 0 so unknowns sort after large known gems.
+      def estimated_size(spec)
+        return spec.size if spec.respond_to?(:size) && spec.size
+        0
+      end
+
+      def local_source_path(spec)
+        source =
+          if spec.respond_to?(:source)
+            spec.source
+          else
+            spec[:source]
+          end
+        return nil unless source
+
+        source_str =
+          if source.respond_to?(:path)
+            source.path.to_s
+          elsif source.respond_to?(:uri) && source.class.name.end_with?("::Path")
+            source.uri.to_s
+          else
+            source.to_s
+          end
+        return nil if source_str.empty?
+        return nil if source_str.start_with?("http://", "https://")
+        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
+      end
+
+      private_class_method :plan_one, :needs_ext_build?, :extension_link_missing?,
+                           :ruby_install_dir, :estimated_size, :local_source_path
+    end
+  end
+end

data/lib/scint/installer/preparer.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require_relative "../downloader/pool"
+require_relative "../gem/package"
+require_relative "../gem/extractor"
+require_relative "../cache/layout"
+require_relative "../fs"
+require_relative "../errors"
+
+module Scint
+  module Installer
+    # Data structures used by the preparer.
+    PlanEntry = Struct.new(:spec, :action, :cached_path, :gem_path, keyword_init: true)
+    PreparedGem = Struct.new(:spec, :extracted_path, :gemspec, :from_cache, keyword_init: true)
+
+    class Preparer
+      attr_reader :results
+
+      # scheduler: optional Scint::Scheduler for enqueuing jobs
+      # layout: Cache::Layout instance
+      # on_progress: optional callback proc
+      def initialize(layout:, scheduler: nil, on_progress: nil)
+        @layout = layout
+        @scheduler = scheduler
+        @on_progress = on_progress
+        @download_pool = Downloader::Pool.new(on_progress: on_progress)
+        @package = GemPkg::Package.new
+        @results = []
+        @mutex = Thread::Mutex.new
+      end
+
+      # Prepare all plan entries: download + extract as needed.
+      # Returns array of PreparedGem.
+      def prepare(entries)
+        # Sort by estimated size descending (larger gems first for better parallelism).
+        # Use version as rough proxy for size if no other info available.
+        sorted = entries.sort_by do |e|
+          s = e.spec
+          name = s.respond_to?(:name) ? s.name : s[:name]
+          -(name.length) # Longer names tend to be larger packages
+        end
+
+        to_download = []
+        already_cached = []
+
+        sorted.each do |entry|
+          inbound = @layout.inbound_path(entry.spec)
+          extracted = @layout.extracted_path(entry.spec)
+
+          if File.directory?(extracted)
+            # Already extracted -- load gemspec from cache or re-read
+            gemspec = load_cached_spec(entry.spec) || read_gemspec_from_extracted(extracted, entry.spec)
+            already_cached << PreparedGem.new(
+              spec: entry.spec,
+              extracted_path: extracted,
+              gemspec: gemspec,
+              from_cache: true,
+            )
+          elsif File.exist?(inbound)
+            # Downloaded but not extracted
+            already_cached << extract_gem(entry.spec, inbound)
+          else
+            # Need to download
+            to_download << entry
+          end
+        end
+
+        begin
+          # Batch download everything that's missing
+          if to_download.any?
+            download_items = to_download.map do |entry|
+              spec = entry.spec
+              source_uri = gem_download_uri(entry)
+
+              {
+                uri: source_uri,
+                dest: @layout.inbound_path(spec),
+                spec: spec,
+                checksum: nil,
+              }
+            end
+
+            download_results = @download_pool.download_batch(download_items)
+
+            download_results.each do |dr|
+              if dr[:error]
+                name = dr[:spec].respond_to?(:name) ? dr[:spec].name : dr[:spec][:name]
+                raise InstallError, "Failed to download #{name}: #{dr[:error].message}"
+              end
+
+              already_cached << extract_gem(dr[:spec], dr[:path])
+            end
+          end
+        ensure
+          @download_pool.close
+        end
+
+        @mutex.synchronize do
+          @results = already_cached
+        end
+
+        already_cached
+      end
+
+      # Prepare a single entry (for use with scheduler).
+      def prepare_one(entry)
+        inbound = @layout.inbound_path(entry.spec)
+        extracted = @layout.extracted_path(entry.spec)
+
+        if File.directory?(extracted)
+          gemspec = load_cached_spec(entry.spec) || read_gemspec_from_extracted(extracted, entry.spec)
+          return PreparedGem.new(
+            spec: entry.spec,
+            extracted_path: extracted,
+            gemspec: gemspec,
+            from_cache: true,
+          )
+        end
+
+        unless File.exist?(inbound)
+          uri = gem_download_uri(entry)
+          @download_pool.download(uri, inbound)
+        end
+
+        extract_gem(entry.spec, inbound)
+      end
+
+      private
+
+      def extract_gem(spec, gem_path)
+        dest = @layout.extracted_path(spec)
+
+        if File.directory?(dest)
+          gemspec = load_cached_spec(spec) || read_gemspec_from_extracted(dest, spec)
+          return PreparedGem.new(spec: spec, extracted_path: dest, gemspec: gemspec, from_cache: true)
+        end
+
+        # Extract to temp dir, then atomic move
+        tmp_dest = "#{dest}.#{Process.pid}.tmp"
+        FileUtils.rm_rf(tmp_dest) if File.exist?(tmp_dest)
+
+        result = @package.extract(gem_path, tmp_dest)
+        FS.atomic_move(tmp_dest, dest)
+
+        # Cache the gemspec as Marshal for fast future loads
+        cache_spec(spec, result[:gemspec])
+
+        PreparedGem.new(
+          spec: spec,
+          extracted_path: dest,
+          gemspec: result[:gemspec],
+          from_cache: false,
+        )
+      end
+
+      def load_cached_spec(spec)
+        path = @layout.spec_cache_path(spec)
+        return nil unless File.exist?(path)
+        Marshal.load(File.binread(path))
+      rescue ArgumentError, TypeError, EOFError
+        nil
+      end
+
+      def cache_spec(spec, gemspec)
+        path = @layout.spec_cache_path(spec)
+        FS.atomic_write(path, Marshal.dump(gemspec))
+      rescue StandardError
+        # Non-fatal: cache miss on next load
+      end
+
+      def read_gemspec_from_extracted(extracted_dir, spec)
+        pattern = File.join(extracted_dir, "*.gemspec")
+        candidates = Dir.glob(pattern)
+        if candidates.any?
+          begin
+            ::Gem::Specification.load(candidates.first)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+
+      def gem_download_uri(entry)
+        spec = entry.spec
+        name = spec.respond_to?(:name) ? spec.name : spec[:name]
+        version = spec.respond_to?(:version) ? spec.version : spec[:version]
+        platform = spec.respond_to?(:platform) ? spec.platform : spec[:platform]
+
+        filename = if platform && platform.to_s != "ruby" && platform.to_s != ""
+                     "#{name}-#{version}-#{platform}.gem"
+                   else
+                     "#{name}-#{version}.gem"
+                   end
+
+        # Use cached_path if provided, otherwise construct from source
+        if entry.cached_path
+          entry.cached_path
+        elsif entry.gem_path
+          entry.gem_path
+        else
+          # Default to rubygems.org
+          "https://rubygems.org/gems/#{filename}"
+        end
+      end
+    end
+  end
+end