scint 0.1.0 → 0.6.0

data/lib/scint/progress.rb

@@ -18,15 +18,22 @@ module Scint
     }.freeze
     BUILD_TAIL_MAX = 6
     BUILD_TAIL_PREVIEW_LINES = 4
-    RENDER_HZ = 5
+    RENDER_HZ = 10
     RENDER_INTERVAL = 1.0 / RENDER_HZ
     MAX_DETAIL_ROWS_PER_PHASE = 4
     MAX_LINE_LEN = 220
     MIN_RENDER_WIDTH = 40
     MAX_PANEL_ROWS = 14
+    SLOW_OPERATION_THRESHOLD_SECONDS = 1.0
     SPINNER_FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
-    IDLE_MARK = "○".freeze
-    PANEL_PHASE_ORDER = %i[download extract build_ext link].freeze
+    IDLE_MARK = "•".freeze
+    PANEL_PHASE_ORDER = %i[download extract link build_ext].freeze
+    COMPLETION_LOG_TYPES = {
+      download: true,
+      extract: true,
+      link: true,
+      build_ext: true,
+    }.freeze
 
     PHASE_LABELS = {
       fetch_index: "Fetching index",
@@ -43,6 +50,12 @@ module Scint
       link: "Installing",
       build_ext: "Compiling",
     }.freeze
+    COMPLETION_LABELS = {
+      download: "Downloaded",
+      extract: "Extracted",
+      link: "Installed",
+      build_ext: "Compiled",
+    }.freeze
 
     def initialize(output: $stderr)
       @output = output
@@ -55,6 +68,7 @@ module Scint
       @failed = Hash.new(0)
       @total = Hash.new(0)
       @active_jobs = {}
+      @job_started_at = {}
       @build_tail = []
       @build_tail_by_name = {}
       @spinner_idx = 0
@@ -67,6 +81,7 @@ module Scint
       @phase_reserved_detail_rows = Hash.new(0)
       @setup_lines_printed = false
       @setup_gap_printed = false
+      @pending_log_lines = []
       @render_stop = false
       @render_thread = nil
     end
@@ -90,8 +105,9 @@ module Scint
 
       @mutex.synchronize do
         begin
+          flush_pending_logs_locked
           mark_completed_phase_elapsed_locked
-          render_live_locked if any_stream_activity?
+          render_live_locked if any_active_stream_jobs?
           if @interactive && @live_rows.positive?
             move_cursor_down(@live_rows - 1)
             @output.print "\r\n"
@@ -119,11 +135,16 @@ module Scint
 
       @mutex.synchronize do
         @active_jobs[job_id] = { type: type, name: name }
+        @job_started_at[job_id] = Process.clock_gettime(Process::CLOCK_MONOTONIC) if completion_log_type?(type)
         @started += 1
         emit_setup_gap_if_needed(type)
         @phase_started_at[type] ||= Process.clock_gettime(Process::CLOCK_MONOTONIC) if stream_type?(type)
-        if @interactive && stream_type?(type)
+        if @interactive
           start_render_thread_locked
+          unless stream_type?(type)
+            clear_live_block_locked
+            emit_setup_or_log_line(type, name)
+          end
         else
           clear_live_block_locked
           emit_setup_or_log_line(type, name)
@@ -136,6 +157,8 @@ module Scint
         @completed[type] += 1
         active = @active_jobs.delete(job_id)
         @build_tail_by_name.delete(active[:name]) if active
+        elapsed = consume_job_elapsed(job_id)
+        emit_task_completion_locked(type, name, elapsed) if @interactive
         if !@interactive || !stream_type?(type)
           emit_phase_completion_locked(type)
         end
@@ -147,11 +170,22 @@ module Scint
 
       @mutex.synchronize do
         active = @active_jobs.delete(job_id)
+        elapsed = consume_job_elapsed(job_id)
         @build_tail_by_name.delete(active[:name]) if active
         @failed[type] += 1
-        clear_live_block_locked
         label = PHASE_LABELS[type] || type.to_s
-        @output.puts "#{RED}FAILED#{RESET} #{label} #{BOLD}#{name}#{RESET}: #{error.message}"
+        failed_timing = if elapsed && elapsed >= SLOW_OPERATION_THRESHOLD_SECONDS
+          " #{DIM}#{format_phase_elapsed(elapsed)}#{RESET}"
+        else
+          ""
+        end
+        failed_line = "#{RED}FAILED#{RESET} #{label} #{BOLD}#{name}#{RESET}: #{error.message}#{failed_timing}"
+        if @interactive
+          queue_log_line_locked(failed_line)
+        else
+          clear_live_block_locked
+          @output.puts failed_line
+        end
         if !@interactive
           emit_phase_completion_locked(type)
         end
@@ -197,9 +231,68 @@ module Scint
       HIDDEN_TYPES[type] == true
     end
 
+    def completion_log_type?(type)
+      COMPLETION_LOG_TYPES[type] == true
+    end
+
+    def consume_job_elapsed(job_id)
+      started_at = @job_started_at.delete(job_id)
+      return nil unless started_at
+
+      Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+    end
+
+    def emit_task_completion_locked(type, name, elapsed)
+      return unless completion_log_type?(type)
+
+      label = COMPLETION_LABELS[type] || (PHASE_LABELS[type] || type.to_s)
+      timing = if elapsed && elapsed >= SLOW_OPERATION_THRESHOLD_SECONDS
+        " #{DIM}#{format_phase_elapsed(elapsed)}#{RESET}"
+      else
+        ""
+      end
+      line = "#{GREEN}#{IDLE_MARK}#{RESET} #{DIM}#{label} #{BOLD}#{name}#{RESET}#{timing}"
+
+      queue_log_line_locked(line)
+    end
+
+    def queue_log_line_locked(line)
+      @pending_log_lines << line
+    end
+
+    def flush_pending_logs_locked
+      return if @pending_log_lines.empty?
+
+      lines = @pending_log_lines.dup
+      @pending_log_lines.clear
+      lines.each_with_index do |line, idx|
+        write_scrollback_line_locked(line, flush: idx == lines.length - 1)
+      end
+    end
+
+    def write_scrollback_line_locked(line, flush: true)
+      rendered = fit_line(line, @render_width)
+
+      unless @interactive && @live_rows.positive?
+        @output.print "\r"
+        @output.puts rendered
+        @output.flush if flush && @output.respond_to?(:flush)
+        return
+      end
+
+      # Insert one scrollback line above the active block without clearing
+      # existing rows first. This reduces visible flicker during fast updates.
+      move_cursor_up(@live_rows - 1)
+      @output.print "\e[1L"
+      @output.print "\r#{rendered}\e[K\n"
+      move_cursor_down(@live_rows - 1)
+      @output.print "\r"
+      @output.flush if flush && @output.respond_to?(:flush)
+    end
+
     def render_live_locked
       return unless @interactive
-      return unless any_stream_activity?
+      return unless any_active_stream_jobs? || any_active_setup_jobs?
 
       mark_completed_phase_elapsed_locked
 
@@ -207,7 +300,11 @@ module Scint
       spinner = SPINNER_FRAMES[@spinner_idx % SPINNER_FRAMES.length]
       @spinner_idx += 1
 
-      lines.concat(phase_lines(spinner))
+      if any_active_stream_jobs?
+        lines.concat(phase_lines(spinner))
+      else
+        lines << "#{GREEN}#{spinner}#{RESET} Processing..."
+      end
       lines = clamp_panel_rows(lines)
 
       redraw_live_block_locked(lines)
@@ -238,7 +335,8 @@ module Scint
     end
 
     def phase_lines(spinner)
-      PANEL_PHASE_ORDER.flat_map do |type|
+      active_types = PANEL_PHASE_ORDER.select { |type| !active_stream_jobs_for(type).empty? }
+      active_types.flat_map do |type|
         phase_rows_for(type, spinner)
       end
     end
@@ -252,69 +350,21 @@ module Scint
       label = PHASE_SUMMARY_LABELS[type] || (PHASE_LABELS[type] || type.to_s)
       line = phase_status_line(type, active, label, completed, total, spinner)
       detail_rows = phase_detail_rows_for(type, active)
-      [line, *reserve_phase_detail_space(type, detail_rows, total, completed, active)]
+      [line, *detail_rows.first(MAX_DETAIL_ROWS_PER_PHASE)]
     end
 
     def phase_status_line(type, active_jobs, label, completed, total, spinner)
       base = "#{label}... (#{completed}/#{total})"
-      if active_jobs.empty?
-        elapsed = @phase_elapsed[type]
-        elapsed_text = elapsed ? " · #{format_phase_elapsed(elapsed)}" : ""
-        "#{DIM}#{IDLE_MARK} #{base}#{elapsed_text}#{RESET}"
-      else
-        name = active_jobs.first[:name]
-        "#{spinner} #{base} · #{BOLD}#{name}#{RESET}"
-      end
+      name = active_jobs.first[:name]
+      "#{GREEN}#{spinner}#{RESET} #{base} · #{BOLD}#{name}#{RESET}"
     end
 
     def phase_detail_rows_for(type, active_jobs)
       return [] if active_jobs.empty?
 
-      if type == :build_ext
-        compile_tail_rows_for(active_jobs.first[:name])
-      else
-        active_rows_for(type, active_jobs)
-      end
-    end
-
-    def reserve_phase_detail_space(type, details, total, completed, active_jobs)
-      if phase_complete?(type, total, completed, active_jobs)
-        @phase_reserved_detail_rows[type] = 0
-        return []
-      end
-
-      desired = [details.length, MAX_DETAIL_ROWS_PER_PHASE].min
-      @phase_reserved_detail_rows[type] = [@phase_reserved_detail_rows[type], desired].max
-      reserved = @phase_reserved_detail_rows[type]
+      return compile_tail_rows_for(active_jobs.first[:name]) if type == :build_ext
 
-      rows = details.first(reserved)
-      while rows.length < reserved
-        rows << "#{DIM}  #{RESET}"
-      end
-      rows
-    end
-
-    def phase_complete?(type, total, completed, active_jobs)
-      return false if total.zero?
-
-      if completed >= total && active_jobs.empty?
-        mark_phase_elapsed_locked(type)
-        return true
-      end
-
-      false
-    end
-
-    def active_rows_for(_type, active_jobs)
-      return [] if active_jobs.empty?
-      if active_jobs.length <= MAX_DETAIL_ROWS_PER_PHASE
-        return active_jobs.map { |job| "  #{BOLD}#{job[:name]}#{RESET}" }
-      end
-
-      rows = active_jobs.first(MAX_DETAIL_ROWS_PER_PHASE - 1).map { |job| "  #{BOLD}#{job[:name]}#{RESET}" }
-      remaining = active_jobs.length - rows.length
-      rows << "#{DIM}  +#{remaining} more#{RESET}"
-      rows
+      []
     end
 
     def compile_tail_rows_for(name)
@@ -330,14 +380,21 @@ module Scint
       @active_jobs.values.select { |job| job[:type] == type }
     end
 
+    def any_active_stream_jobs?
+      STREAM_TYPES.keys.any? { |type| !active_stream_jobs_for(type).empty? }
+    end
+
+    def any_active_setup_jobs?
+      @active_jobs.values.any? { |job| SETUP_TYPES[job[:type]] == true }
+    end
+
     def clear_live_block_locked
       return unless @interactive
       return if @live_rows.zero?
 
       move_cursor_up(@live_rows - 1)
       @live_rows.times do |idx|
-        prev_width = @rendered_widths[idx] || 0
-        @output.print "\r#{' ' * prev_width}"
+        @output.print "\r\e[K"
         @output.print "\n" if idx < (@live_rows - 1)
       end
       move_cursor_up(@live_rows - 1)
@@ -350,7 +407,6 @@ module Scint
     def redraw_live_block_locked(lines)
       hide_cursor_locked
       previous_rows = @live_rows
-      previous_widths = @rendered_widths.dup
 
       move_cursor_up(previous_rows - 1) if previous_rows.positive?
 
@@ -359,12 +415,8 @@ module Scint
 
       max_rows.times do |idx|
         line = idx < lines.length ? fit_line(lines[idx], @render_width) : ""
-        prev_width = previous_widths[idx] || 0
         line_width = visible_width(line)
-        pad_len = prev_width > line_width ? (prev_width - line_width) : 0
-        pad = pad_len.positive? ? (" " * pad_len) : ""
-
-        @output.print "\r#{line}#{pad}"
+        @output.print "\r#{line}\e[K"
         @output.print "\n" if idx < (max_rows - 1)
         new_widths << line_width
       end
@@ -405,7 +457,8 @@ module Scint
           @mutex.synchronize do
             should_stop = @render_stop
             unless should_stop
-              render_live_locked
+              flush_pending_logs_locked
+              render_live_locked if any_active_stream_jobs?
               should_stop = render_done_locked?
             end
           end
@@ -502,7 +555,9 @@ module Scint
     end
 
     def render_done_locked?
-      any_stream_activity? && !stream_active_or_pending?
+      !any_active_stream_jobs? && !any_active_setup_jobs? &&
+        @pending_log_lines.empty? &&
+        (!any_stream_activity? || !stream_active_or_pending?)
     end
 
     def format_phase_elapsed(seconds)

data/lib/scint/resolver/provider.rb

@@ -65,8 +65,9 @@ module Scint
           else
             entries = info_for(name)
             versions = {}
-            entries.each do |_name, version, platform, _deps, _reqs|
+            entries.each do |_name, version, platform, _deps, reqs|
               next unless platform_match?(platform)
+              next unless requirements_match?(reqs)
               ver = Gem::Version.new(version)
               versions[version] ||= ver
             end
@@ -93,8 +94,9 @@ module Scint
             entries = info_for(name)
             deps = {}
 
-            entries.each do |_name, ver, platform, dep_hash, _reqs|
+            entries.each do |_name, ver, platform, dep_hash, reqs|
               next unless ver == version_str && platform_match?(platform)
+              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(", "))
@@ -119,8 +121,9 @@ module Scint
         version_str = version.to_s
         entries = info_for(name)
         has_platform_specific = false
-        entries.each do |_name, ver, platform, _deps, _reqs|
+        entries.each do |_name, ver, platform, _deps, reqs|
           next unless ver == version_str
+          next unless requirements_match?(reqs)
           has_platform_specific = true if platform != "ruby"
         end
         has_platform_specific
@@ -132,8 +135,8 @@ module Scint
         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)
+        entries = info_for(name).select do |_n, ver, platform, _deps, reqs|
+          ver == version_str && platform_match?(platform) && requirements_match?(reqs)
         end
         return "ruby" if entries.empty?
 
@@ -225,6 +228,54 @@ module Scint
         combined = req1.requirements + req2.requirements
         Gem::Requirement.new(combined.map { |op, v| "#{op} #{v}" })
       end
+
+      def requirements_match?(reqs)
+        return true unless reqs.is_a?(Hash)
+
+        ruby_req = reqs["ruby"] || reqs[:ruby]
+        return false unless requirement_satisfied?(ruby_req, Gem::Version.new(RUBY_VERSION), ignore_upper: ignore_ruby_upper_bounds?) if ruby_req
+
+        rubygems_req = reqs["rubygems"] || reqs[:rubygems]
+        return false unless requirement_satisfied?(rubygems_req, Gem::Version.new(Gem::VERSION), ignore_upper: false) if rubygems_req
+
+        true
+      rescue StandardError
+        # Keep resolver tolerant of malformed compact-index requirement fields.
+        true
+      end
+
+      def ignore_ruby_upper_bounds?
+        raw = ENV["SCINT_IGNORE_RUBY_UPPER_BOUNDS"]
+        return true if raw.nil?
+
+        !%w[0 false no off].include?(raw.strip.downcase)
+      end
+
+      def requirement_satisfied?(requirement_str, current_version, ignore_upper:)
+        req = normalize_requirement(requirement_str, ignore_upper: ignore_upper)
+        req.satisfied_by?(current_version)
+      end
+
+      def normalize_requirement(requirement_str, ignore_upper:)
+        parts = requirement_str.to_s.split(",").map(&:strip).reject(&:empty?)
+        req = Gem::Requirement.new(*(parts.empty? ? [">= 0"] : parts))
+        return req unless ignore_upper
+
+        filtered = req.requirements.filter_map do |op, version|
+          case op
+          when "<", "<="
+            nil
+          when "~>"
+            [">=", version]
+          else
+            [op, version]
+          end
+        end
+
+        return Gem::Requirement.default if filtered.empty?
+
+        Gem::Requirement.new(filtered.map { |op, version| "#{op} #{version}" })
+      end
     end
   end
 end

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

@@ -1,3 +1,7 @@
 module Scint::PubGrub
-  VERSION = "0.5.0"
+  VERSION = if defined?(::Scint::VERSION)
+    ::Scint::VERSION
+  else
+    File.read(File.expand_path("../../../../VERSION", __dir__)).strip
+  end
 end

data/lib/scint/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Scint
+  VERSION = File.read(File.expand_path("../../VERSION", __dir__)).strip
+end

data/lib/scint.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Scint
-  VERSION = "0.1.0"
+require_relative "scint/version"
 
+module Scint
   # Color support: respects NO_COLOR (https://no-color.org) and TERM=dumb.
   COLOR = !ENV.key?("NO_COLOR") && ENV["TERM"] != "dumb" && $stderr.tty?
 

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: scint
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.6.0
 platform: ruby
 authors:
-- Scint Contributors
+- Tobi Lutke
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
@@ -16,17 +16,13 @@ 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
+- VERSION
 - bin/scint
-- bin/scint-io-summary
-- bin/scint-syscall-trace
 - lib/bundler.rb
 - lib/bundler/setup.rb
 - lib/scint.rb
@@ -90,6 +86,7 @@ files:
 - 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/version.rb
 - lib/scint/worker_pool.rb
 homepage: https://example.com/scint
 licenses: