scint 0.1.0

data/lib/scint/vendor/pub_grub/version_union.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Scint::PubGrub
+  class VersionUnion
+    attr_reader :ranges
+
+    def self.normalize_ranges(ranges)
+      ranges = ranges.flat_map do |range|
+        range.ranges
+      end
+
+      ranges.reject!(&:empty?)
+
+      return [] if ranges.empty?
+
+      mins, ranges = ranges.partition { |r| !r.min }
+      original_ranges = mins + ranges.sort_by { |r| [r.min, r.include_min ? 0 : 1] }
+      ranges = [original_ranges.shift]
+      original_ranges.each do |range|
+        if ranges.last.contiguous_to?(range)
+          ranges << ranges.pop.span(range)
+        else
+          ranges << range
+        end
+      end
+
+      ranges
+    end
+
+    def self.union(ranges, normalize: true)
+      ranges = normalize_ranges(ranges) if normalize
+
+      if ranges.size == 0
+        VersionRange.empty
+      elsif ranges.size == 1
+        ranges[0]
+      else
+        new(ranges)
+      end
+    end
+
+    def initialize(ranges)
+      raise ArgumentError unless ranges.all? { |r| r.instance_of?(VersionRange) }
+      @ranges = ranges
+    end
+
+    def hash
+      ranges.hash
+    end
+
+    def eql?(other)
+      ranges.eql?(other.ranges)
+    end
+
+    def include?(version)
+      !!ranges.bsearch {|r| r.compare_version(version) }
+    end
+
+    def select_versions(all_versions)
+      versions = []
+      ranges.inject(all_versions) do |acc, range|
+        _, matching, higher = range.partition_versions(acc)
+        versions.concat matching
+        higher
+      end
+      versions
+    end
+
+    def intersects?(other)
+      my_ranges = ranges.dup
+      other_ranges = other.ranges.dup
+
+      my_range = my_ranges.shift
+      other_range = other_ranges.shift
+      while my_range && other_range
+        if my_range.intersects?(other_range)
+          return true
+        end
+
+        if !my_range.max || other_range.empty? || (other_range.max && other_range.max < my_range.max)
+          other_range = other_ranges.shift
+        else
+          my_range = my_ranges.shift
+        end
+      end
+    end
+    alias_method :allows_any?, :intersects?
+
+    def allows_all?(other)
+      my_ranges = ranges.dup
+
+      my_range = my_ranges.shift
+
+      other.ranges.all? do |other_range|
+        while my_range
+          break if my_range.allows_all?(other_range)
+          my_range = my_ranges.shift
+        end
+
+        !!my_range
+      end
+    end
+
+    def empty?
+      false
+    end
+
+    def any?
+      false
+    end
+
+    def intersect(other)
+      my_ranges = ranges.dup
+      other_ranges = other.ranges.dup
+      new_ranges = []
+
+      my_range = my_ranges.shift
+      other_range = other_ranges.shift
+      while my_range && other_range
+        new_ranges << my_range.intersect(other_range)
+
+        if !my_range.max || other_range.empty? || (other_range.max && other_range.max < my_range.max)
+          other_range = other_ranges.shift
+        else
+          my_range = my_ranges.shift
+        end
+      end
+      new_ranges.reject!(&:empty?)
+      VersionUnion.union(new_ranges, normalize: false)
+    end
+
+    def upper_invert
+      ranges.last.upper_invert
+    end
+
+    def invert
+      ranges.map(&:invert).inject(:intersect)
+    end
+
+    def union(other)
+      VersionUnion.union([self, other])
+    end
+
+    def to_s
+      output = []
+
+      ranges = self.ranges.dup
+      while !ranges.empty?
+        ne = []
+        range = ranges.shift
+        while !ranges.empty? && ranges[0].min.to_s == range.max.to_s
+          ne << range.max
+          range = range.span(ranges.shift)
+        end
+
+        ne.map! {|x| "!= #{x}" }
+        if ne.empty?
+          output << range.to_s
+        elsif range.any?
+          output << ne.join(', ')
+        else
+          output << "#{range}, #{ne.join(', ')}"
+        end
+      end
+
+      output.join(" OR ")
+    end
+
+    def inspect
+      "#<#{self.class} #{to_s}>"
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        self.ranges == other.ranges
+    end
+  end
+end

data/lib/scint/vendor/pub_grub.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Vendored PubGrub loader - loads all PubGrub modules under Scint::PubGrub
+require "logger"
+
+module Scint
+  module PubGrub
+    def self.logger
+      @logger ||= ::Logger.new($stderr, level: ::Logger::WARN)
+    end
+
+    def self.logger=(logger)
+      @logger = logger
+    end
+  end
+end
+
+require_relative "pub_grub/version"
+require_relative "pub_grub/version_range"
+require_relative "pub_grub/version_union"
+require_relative "pub_grub/version_constraint"
+require_relative "pub_grub/package"
+require_relative "pub_grub/term"
+require_relative "pub_grub/assignment"
+require_relative "pub_grub/incompatibility"
+require_relative "pub_grub/partial_solution"
+require_relative "pub_grub/solve_failure"
+require_relative "pub_grub/failure_writer"
+require_relative "pub_grub/strategy"
+require_relative "pub_grub/version_solver"
+require_relative "pub_grub/basic_package_source"
+require_relative "pub_grub/rubygems"

data/lib/scint/worker_pool.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Scint
+  class WorkerPool
+    POISON = :__scint_poison__
+
+    attr_reader :size
+
+    def initialize(size, name: "worker")
+      @max_size = size
+      @size = 0
+      @name = name
+      @queue = Thread::Queue.new
+      @workers = []
+      @started = false
+      @stopped = false
+      @mutex = Thread::Mutex.new
+    end
+
+    # Start worker threads. initial_count defaults to max_size for backward compat.
+    # The block receives (job) and should return a result or raise.
+    def start(initial_count = nil, &block)
+      raise "already started" if @started
+      raise "no block given" unless block
+
+      @started = true
+      @handler = block
+
+      count = [initial_count || @max_size, @max_size].min
+      spawn_workers(count)
+    end
+
+    # Grow the pool to target size (clamped to max). Never shrinks.
+    # Safe to call from any thread.
+    def grow_to(target)
+      @mutex.synchronize do
+        return unless @started && !@stopped
+        target = [target, @max_size].min
+        return if target <= @size
+
+        spawn_workers(target - @size)
+      end
+    end
+
+    # Enqueue a job. Returns the job hash for tracking.
+    def enqueue(payload, &callback)
+      raise "not started" unless @started
+      raise "pool is stopped" if @stopped
+
+      job = {
+        payload: payload,
+        state: :pending,
+        result: nil,
+        error: nil,
+        callback: callback,
+      }
+      @queue.push(job)
+      job
+    end
+
+    # Signal all workers to stop after finishing current work.
+    def stop
+      current_size = nil
+      @mutex.synchronize do
+        return if @stopped
+        @stopped = true
+        current_size = @size
+      end
+
+      current_size.times { @queue.push(POISON) }
+      @workers.each { |w| w.join }
+    end
+
+    def running?
+      @started && !@stopped
+    end
+
+    private
+
+    # Must be called inside @mutex (or during init before threads start)
+    def spawn_workers(count)
+      base = @workers.size
+      count.times do |i|
+        @workers << Thread.new do
+          Thread.current.name = "#{@name}-#{base + i}"
+          loop do
+            job = @queue.pop
+            break if job == POISON
+
+            # Never let an exception kill the worker thread while a job is
+            # in flight, or scheduler waiters can block forever.
+            begin
+              job[:result] = @handler.call(job[:payload])
+              job[:state] = :completed
+            rescue Exception => e
+              job[:error] = e
+              job[:state] = :failed
+            end
+
+            begin
+              job[:callback]&.call(job)
+            rescue Exception => e
+              $stderr.puts "Worker callback error: #{e.class}: #{e.message}"
+              $stderr.puts e.backtrace.first(5).map { |l| "  #{l}" }.join("\n")
+              job[:error] ||= e
+              job[:state] = :failed
+            end
+          end
+        end
+      end
+      @size += count
+    end
+  end
+end

data/lib/scint.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Scint
+  VERSION = "0.1.0"
+
+  # Color support: respects NO_COLOR (https://no-color.org) and TERM=dumb.
+  COLOR = !ENV.key?("NO_COLOR") && ENV["TERM"] != "dumb" && $stderr.tty?
+
+  GREEN  = COLOR ? "\e[32m" : ""
+  RED    = COLOR ? "\e[31m" : ""
+  YELLOW = COLOR ? "\e[33m" : ""
+  BOLD   = COLOR ? "\e[1m"  : ""
+  DIM    = COLOR ? "\e[2m"  : ""
+  RESET  = COLOR ? "\e[0m"  : ""
+
+  # XDG-based cache root
+  def self.cache_root
+    @cache_root ||= File.join(
+      ENV.fetch("XDG_CACHE_HOME", File.join(Dir.home, ".cache")),
+      "scint"
+    )
+  end
+
+  def self.cache_root=(path)
+    @cache_root = path
+  end
+
+  # Shared data structures used across all modules
+  Dependency = Struct.new(
+    :name, :version_reqs, :source, :groups, :platforms, :require_paths,
+    keyword_init: true
+  )
+
+  LockedSpec = Struct.new(
+    :name, :version, :platform, :dependencies, :source, :checksum,
+    keyword_init: true
+  )
+
+  ResolvedSpec = Struct.new(
+    :name, :version, :platform, :dependencies, :source, :has_extensions,
+    :remote_uri, :checksum,
+    keyword_init: true
+  )
+
+  PlanEntry = Struct.new(
+    :spec, :action, :cached_path, :gem_path,
+    keyword_init: true
+  )
+
+  PreparedGem = Struct.new(
+    :spec, :extracted_path, :gemspec, :from_cache,
+    keyword_init: true
+  )
+
+  # Autoloads — each file is loaded on first reference
+  autoload :CLI,         "scint/cli"
+  autoload :Scheduler,   "scint/scheduler"
+  autoload :WorkerPool,  "scint/worker_pool"
+  autoload :Progress,    "scint/progress"
+  autoload :FS,          "scint/fs"
+  autoload :Platform,    "scint/platform"
+
+  # Errors
+  autoload :BundlerError,        "scint/errors"
+  autoload :GemfileError,        "scint/errors"
+  autoload :LockfileError,       "scint/errors"
+  autoload :ResolveError,        "scint/errors"
+  autoload :NetworkError,        "scint/errors"
+  autoload :InstallError,        "scint/errors"
+  autoload :ExtensionBuildError, "scint/errors"
+  autoload :PermissionError,     "scint/errors"
+  autoload :PlatformError,       "scint/errors"
+  autoload :CacheError,          "scint/errors"
+
+  # Submodule namespaces — defined here so autoloads don't trigger
+  # when files inside these modules reference the module name.
+  module Gemfile; end
+  module Lockfile; end
+  module Resolver; end
+  module Index; end
+  module Downloader; end
+  module Cache; end
+  module Installer; end
+  module Source; end
+  module Runtime; end
+  # NOTE: we do NOT define `module Gem` here — it would shadow ::Gem
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: scint
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Scint Contributors
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Scint is a Bundler-compatible dependency installer that uses a scheduler-driven,
+  phase-oriented architecture to maximize parallel throughput while preserving Gemfile/Gemfile.lock
+  behavior.
+email:
+- maintainers@example.com
+executables:
+- scint
+- scint-io-summary
+- scint-syscall-trace
+extensions: []
+extra_rdoc_files: []
+files:
+- FEATURES.md
+- README.md
+- bin/bundler-vs-scint
+- bin/scint
+- bin/scint-io-summary
+- bin/scint-syscall-trace
+- lib/bundler.rb
+- lib/bundler/setup.rb
+- lib/scint.rb
+- lib/scint/cache/layout.rb
+- lib/scint/cache/metadata_store.rb
+- lib/scint/cache/prewarm.rb
+- lib/scint/cli.rb
+- lib/scint/cli/add.rb
+- lib/scint/cli/cache.rb
+- lib/scint/cli/exec.rb
+- lib/scint/cli/install.rb
+- lib/scint/cli/remove.rb
+- lib/scint/commands/exec.rb
+- lib/scint/commands/install.rb
+- lib/scint/credentials.rb
+- lib/scint/debug/io_trace.rb
+- lib/scint/debug/sampler.rb
+- lib/scint/downloader/fetcher.rb
+- lib/scint/downloader/pool.rb
+- lib/scint/errors.rb
+- lib/scint/fs.rb
+- lib/scint/gem/extractor.rb
+- lib/scint/gem/package.rb
+- lib/scint/gemfile/dependency.rb
+- lib/scint/gemfile/editor.rb
+- lib/scint/gemfile/parser.rb
+- lib/scint/index/cache.rb
+- lib/scint/index/client.rb
+- lib/scint/index/parser.rb
+- lib/scint/installer/extension_builder.rb
+- lib/scint/installer/linker.rb
+- lib/scint/installer/planner.rb
+- lib/scint/installer/preparer.rb
+- lib/scint/lockfile/parser.rb
+- lib/scint/lockfile/writer.rb
+- lib/scint/platform.rb
+- lib/scint/progress.rb
+- lib/scint/resolver/provider.rb
+- lib/scint/resolver/resolver.rb
+- lib/scint/runtime/exec.rb
+- lib/scint/runtime/setup.rb
+- lib/scint/scheduler.rb
+- lib/scint/source/base.rb
+- lib/scint/source/git.rb
+- lib/scint/source/path.rb
+- lib/scint/source/rubygems.rb
+- lib/scint/vendor/pub_grub.rb
+- lib/scint/vendor/pub_grub/assignment.rb
+- lib/scint/vendor/pub_grub/basic_package_source.rb
+- lib/scint/vendor/pub_grub/failure_writer.rb
+- lib/scint/vendor/pub_grub/incompatibility.rb
+- lib/scint/vendor/pub_grub/package.rb
+- lib/scint/vendor/pub_grub/partial_solution.rb
+- lib/scint/vendor/pub_grub/rubygems.rb
+- lib/scint/vendor/pub_grub/solve_failure.rb
+- lib/scint/vendor/pub_grub/static_package_source.rb
+- lib/scint/vendor/pub_grub/strategy.rb
+- lib/scint/vendor/pub_grub/term.rb
+- lib/scint/vendor/pub_grub/version.rb
+- lib/scint/vendor/pub_grub/version_constraint.rb
+- lib/scint/vendor/pub_grub/version_range.rb
+- lib/scint/vendor/pub_grub/version_solver.rb
+- lib/scint/vendor/pub_grub/version_union.rb
+- lib/scint/worker_pool.rb
+homepage: https://example.com/scint
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://example.com/scint
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Fast Bundler-compatible installer with phased parallel execution
+test_files: []