taski 0.8.2 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ecbd73a50d1f39207625cda94e9f90a90ce212d270a70ed49cd94705bb30a5c
-  data.tar.gz: d5efd7fcf8c5c0d5bdfacf147e302375e63d41acd00f428924e87ba3a4e54ac0
+  metadata.gz: cddae184fb1f55c69b42995e51c3bf5711d31f978ec383a00a73d2ce3531ca15
+  data.tar.gz: 3e79ca2bf3a6cd163272bbff98ff3b980f3a3b69293607dd45879501d50904c4
 SHA512:
-  metadata.gz: e263e9c974f17ff46f545adc3cf90cddf66cbfe273c783d07f036a2d3fc4c7f8ec4759c1a94ff72ab0b302d8c4fae50a4654cda5b4b17d9f218ae897ba67572a
-  data.tar.gz: 9bf8d6b053ee781ef9ba2535926ef663be9ed45d88249d59a5325d7cbd600468ae5bacc69e506ae5bc7f2819707b9e4451a0faf0aa377dbbfb33fe04a7d9199b
+  metadata.gz: 9310e8b52be98d9087de88b4b7f5d105896edd85137c2f43e6c968c8daaf00dc6b4843ff9d1f228a089dcd7ceb379715c2b640d3c547ce173659dc7130cd1768
+  data.tar.gz: 65bade2024691c9c7527f6249294d01714563ff35c211472e6d984e82ba5acd0767251d33e05d8ade4208eabc8b1326eb47fc4f932b4699bf0b986e208fffcea

data/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.3] - 2026-01-26
+
+### Fixed
+- Improve progress display accuracy for section candidates ([#136](https://github.com/ahogappa/taski/pull/136))
+
+### Changed
+- Extract helper methods for improved readability ([#136](https://github.com/ahogappa/taski/pull/136))
+
 ## [0.8.2] - 2026-01-26
 
 ### Fixed

data/lib/taski/execution/base_progress_display.rb

@@ -290,8 +290,30 @@ module Taski
         @output.tty?
       end
 
+      # Collect all dependencies of a task class recursively
+      # Useful for determining which tasks are needed by a selected implementation
+      # @param task_class [Class] The task class to collect dependencies for
+      # @return [Set<Class>] Set of all dependency task classes (including the task itself)
+      def collect_all_dependencies(task_class)
+        deps = Set.new
+        collect_dependencies_recursive(task_class, deps)
+        deps
+      end
+
       private
 
+      # Recursively collect dependencies into the given set
+      # @param task_class [Class] The task class
+      # @param collected [Set<Class>] Accumulated dependencies
+      def collect_dependencies_recursive(task_class, collected)
+        return if collected.include?(task_class)
+        collected.add(task_class)
+
+        task_class.cached_dependencies.each do |dep|
+          collect_dependencies_recursive(dep, collected)
+        end
+      end
+
       # Flush all queued messages to output.
       # Called when progress display stops.
       def flush_queued_messages
@@ -300,12 +322,15 @@ module Taski
       end
 
       # Apply state transition to TaskProgress
+      # Note: Once a task reaches :completed or :failed, it cannot go back to :running.
+      # This prevents progress count from decreasing when nested executors re-execute tasks.
       def apply_state_transition(progress, state, duration, error)
         case state
         # Run lifecycle states
         when :pending
           progress.run_state = :pending
         when :running
+          return if run_state_finalized?(progress)
           progress.run_state = :running
           progress.run_start_time = Time.now
         when :completed
@@ -331,6 +356,10 @@ module Taski
         end
       end
 
+      def run_state_finalized?(progress)
+        progress.run_state == :completed || progress.run_state == :failed
+      end
+
       # Apply state transition to GroupProgress
       def apply_group_state_transition(progress, group_name, state, duration, error)
         case state

data/lib/taski/execution/simple_progress_display.rb

@@ -35,6 +35,7 @@ module Taski
         @renderer_thread = nil
         @running = false
         @section_candidates = {} # section_class => [candidate_classes]
+        @section_candidate_subtrees = {} # section_class => { candidate_class => subtree_node }
       end
 
       protected
@@ -50,18 +51,9 @@ module Taski
         @tasks[impl_class].is_impl_candidate = false
 
         # Mark the section itself as completed (it's represented by its impl)
-        if @tasks[section_class]
-          @tasks[section_class].run_state = :completed
-        end
+        @tasks[section_class]&.run_state = :completed
 
-        # Mark unselected candidates as completed (skipped)
-        candidates = @section_candidates[section_class] || []
-        candidates.each do |candidate|
-          next if candidate == impl_class
-          progress = @tasks[candidate]
-          next unless progress
-          progress.run_state = :completed
-        end
+        mark_unselected_candidates_completed(section_class, impl_class)
       end
 
       # Template method: Determine if display should activate
@@ -106,17 +98,50 @@ module Taski
 
         task_class = node[:task_class]
 
-        # If this is a section, collect its implementation candidates
+        # If this is a section, collect its implementation candidates and their subtrees
         if node[:is_section]
-          candidates = node[:children]
-            .select { |c| c[:is_impl_candidate] }
-            .map { |c| c[:task_class] }
+          candidate_nodes = node[:children].select { |c| c[:is_impl_candidate] }
+          candidates = candidate_nodes.map { |c| c[:task_class] }
           @section_candidates[task_class] = candidates unless candidates.empty?
+
+          # Store subtrees for each candidate to mark descendants as completed when not selected
+          subtrees = {}
+          candidate_nodes.each { |c| subtrees[c[:task_class]] = c }
+          @section_candidate_subtrees[task_class] = subtrees unless subtrees.empty?
         end
 
         node[:children].each { |child| collect_section_candidates(child) }
       end
 
+      # Mark unselected candidates and their exclusive subtrees as completed (skipped)
+      def mark_unselected_candidates_completed(section_class, impl_class)
+        selected_deps = collect_all_dependencies(impl_class)
+        candidates = @section_candidates[section_class] || []
+        subtrees = @section_candidate_subtrees[section_class] || {}
+
+        candidates.each do |candidate|
+          next if candidate == impl_class
+          mark_subtree_completed(subtrees[candidate], exclude: selected_deps)
+        end
+      end
+
+      # Recursively mark all pending tasks in a subtree as completed (skipped)
+      # Only marks :pending tasks to avoid overwriting :running or :completed states
+      # @param node [Hash] The subtree node
+      # @param exclude [Set<Class>] Set of task classes to exclude (dependencies of selected impl)
+      def mark_subtree_completed(node, exclude: Set.new)
+        return unless node
+
+        task_class = node[:task_class]
+        mark_task_as_skipped(task_class) unless exclude.include?(task_class)
+        node[:children].each { |child| mark_subtree_completed(child, exclude: exclude) }
+      end
+
+      def mark_task_as_skipped(task_class)
+        progress = @tasks[task_class]
+        progress.run_state = :completed if progress&.run_state == :pending
+      end
+
       def render_live
         @monitor.synchronize do
           @spinner_index = (@spinner_index + 1) % SPINNER_FRAMES.size
@@ -153,37 +178,53 @@ module Taski
       def build_status_line
         running_tasks = @tasks.select { |_, p| p.run_state == :running }
         cleaning_tasks = @tasks.select { |_, p| p.clean_state == :cleaning }
-        # Count both completed and failed tasks as "done"
-        done = @tasks.values.count { |p| p.run_state == :completed || p.run_state == :failed }
-        failed = @tasks.values.count { |p| p.run_state == :failed }
-        total = @tasks.size
+        pending_tasks = @tasks.select { |_, p| p.run_state == :pending }
+        failed_count = @tasks.values.count { |p| p.run_state == :failed }
+        done_count = @tasks.values.count { |p| p.run_state == :completed || p.run_state == :failed }
+
+        status_icon = determine_status_icon(failed_count, running_tasks, cleaning_tasks, pending_tasks)
+        task_names = format_current_task_names(cleaning_tasks, running_tasks, pending_tasks)
 
-        spinner = SPINNER_FRAMES[@spinner_index]
-        status_icon = if failed > 0
+        primary_task = running_tasks.keys.first || cleaning_tasks.keys.first
+        output_suffix = build_output_suffix(primary_task)
+
+        build_status_parts(status_icon, done_count, @tasks.size, task_names, output_suffix)
+      end
+
+      def determine_status_icon(failed_count, running_tasks, cleaning_tasks, pending_tasks)
+        # Show success only when no failed, running, cleaning, or pending tasks
+        # This prevents showing checkmark briefly when mark_subtree_completed marks tasks
+        if failed_count > 0
           "#{COLORS[:red]}#{ICONS[:failure]}#{COLORS[:reset]}"
-        elsif running_tasks.any? || cleaning_tasks.any?
+        elsif running_tasks.any? || cleaning_tasks.any? || pending_tasks.any?
+          spinner = SPINNER_FRAMES[@spinner_index]
           "#{COLORS[:yellow]}#{spinner}#{COLORS[:reset]}"
         else
           "#{COLORS[:green]}#{ICONS[:success]}#{COLORS[:reset]}"
         end
+      end
 
-        # Get current task names
+      def format_current_task_names(cleaning_tasks, running_tasks, pending_tasks)
+        # Prioritize: cleaning > running > pending
         current_tasks = if cleaning_tasks.any?
-          cleaning_tasks.keys.map { |t| short_name(t) }
+          cleaning_tasks.keys
+        elsif running_tasks.any?
+          running_tasks.keys
+        elsif pending_tasks.any?
+          pending_tasks.keys.first(3)
         else
-          running_tasks.keys.map { |t| short_name(t) }
+          []
         end
 
-        task_names = current_tasks.first(3).join(", ")
-        task_names += "..." if current_tasks.size > 3
-
-        # Get last output message if available
-        output_suffix = build_output_suffix(running_tasks.keys.first || cleaning_tasks.keys.first)
+        names = current_tasks.first(3).map { |t| short_name(t) }.join(", ")
+        names += "..." if current_tasks.size > 3
+        names
+      end
 
-        parts = ["#{status_icon} [#{done}/#{total}]"]
-        parts << task_names if task_names && !task_names.empty?
+      def build_status_parts(status_icon, done_count, total, task_names, output_suffix)
+        parts = ["#{status_icon} [#{done_count}/#{total}]"]
+        parts << task_names unless task_names.empty?
         parts << "|" << output_suffix if output_suffix
-
         parts.join(" ")
       end
 

data/lib/taski/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Taski
-  VERSION = "0.8.2"
+  VERSION = "0.8.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taski
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.8.3
 platform: ruby
 authors:
 - ahogappa