taski 0.8.1 → 0.8.3

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
@@ -49,14 +50,10 @@ module Taski
         @tasks[impl_class] ||= TaskProgress.new
         @tasks[impl_class].is_impl_candidate = false
 
-        # 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 the section itself as completed (it's represented by its impl)
+        @tasks[section_class]&.run_state = :completed
+
+        mark_unselected_candidates_completed(section_class, impl_class)
       end
 
       # Template method: Determine if display should activate
@@ -101,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
@@ -148,36 +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 }
-        completed = @tasks.values.count { |p| p.run_state == :completed }
-        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} [#{completed}/#{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/execution/task_output_router.rb

@@ -22,9 +22,10 @@ module Taski
       READ_BUFFER_SIZE = 4096
       MAX_RECENT_LINES = 30 # Maximum number of recent lines to keep per task
 
-      def initialize(original_stdout)
+      def initialize(original_stdout, execution_context = nil)
         super()
         @original = original_stdout
+        @execution_context = execution_context
         @pipes = {}         # task_class => TaskOutputPipe
         @thread_map = {}    # Thread => task_class
         @recent_lines = {}  # task_class => Array<String>

data/lib/taski/version.rb

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

data/lib/taski.rb

@@ -162,9 +162,9 @@ module Taski
   # @param text [String] The message text to display
   def self.message(text)
     @message_monitor.synchronize do
-      context = Execution::ExecutionContext.current
-      if context&.output_capture_active?
-        context.queue_message(text)
+      progress = progress_display
+      if progress&.respond_to?(:queue_message)
+        progress.queue_message(text)
       else
         $stdout.puts(text)
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taski
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.3
 platform: ruby
 authors:
 - ahogappa
@@ -59,18 +59,12 @@ files:
 - examples/README.md
 - examples/args_demo.rb
 - examples/clean_demo.rb
-- examples/data_pipeline_demo.rb
 - examples/group_demo.rb
-- examples/large_tree_demo.rb
 - examples/message_demo.rb
-- examples/nested_section_demo.rb
-- examples/parallel_progress_demo.rb
+- examples/progress_demo.rb
 - examples/quick_start.rb
 - examples/reexecution_demo.rb
 - examples/section_demo.rb
-- examples/simple_progress_demo.rb
-- examples/system_call_demo.rb
-- examples/tree_progress_demo.rb
 - lib/taski.rb
 - lib/taski/args.rb
 - lib/taski/env.rb

data/examples/data_pipeline_demo.rb

@@ -1,231 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Taski Data Pipeline Example
-#
-# This example demonstrates a realistic data processing pipeline:
-# - Section API for switching data sources (production vs test)
-# - Multiple data sources fetched in parallel
-# - Data transformation and aggregation
-#
-# Run: ruby examples/data_pipeline_demo.rb
-# Disable progress: TASKI_PROGRESS_DISABLE=1 ruby examples/data_pipeline_demo.rb
-
-require_relative "../lib/taski"
-
-# Section: Data source abstraction
-# Switch between production API and test fixtures
-class DataSourceSection < Taski::Section
-  interfaces :users, :sales, :activities
-
-  def impl
-    (ENV["USE_TEST_DATA"] == "true") ? TestData : ProductionData
-  end
-
-  # Production: Fetch from APIs (simulated with delays)
-  class ProductionData < Taski::Task
-    def run
-      puts "  [ProductionData] Fetching from APIs..."
-      sleep(0.3)
-
-      @users = [
-        {id: 1, name: "Alice", department: "Engineering"},
-        {id: 2, name: "Bob", department: "Sales"},
-        {id: 3, name: "Charlie", department: "Engineering"},
-        {id: 4, name: "Diana", department: "Marketing"}
-      ]
-
-      @sales = [
-        {user_id: 2, amount: 1000, date: "2024-01"},
-        {user_id: 2, amount: 1500, date: "2024-02"},
-        {user_id: 4, amount: 800, date: "2024-01"}
-      ]
-
-      @activities = [
-        {user_id: 1, action: :commit, count: 45},
-        {user_id: 3, action: :commit, count: 32},
-        {user_id: 1, action: :review, count: 12},
-        {user_id: 3, action: :review, count: 8}
-      ]
-
-      puts "  [ProductionData] Loaded #{@users.size} users, #{@sales.size} sales, #{@activities.size} activities"
-    end
-  end
-
-  # Test: Minimal fixture data (no delays)
-  class TestData < Taski::Task
-    def run
-      puts "  [TestData] Loading test fixtures..."
-
-      @users = [
-        {id: 1, name: "Test User", department: "Test Dept"}
-      ]
-
-      @sales = [
-        {user_id: 1, amount: 100, date: "2024-01"}
-      ]
-
-      @activities = [
-        {user_id: 1, action: :commit, count: 10}
-      ]
-
-      puts "  [TestData] Loaded minimal test data"
-    end
-  end
-end
-
-# Section: Report format selection
-class ReportFormatSection < Taski::Section
-  interfaces :format_report
-
-  def impl
-    (ENV["REPORT_FORMAT"] == "json") ? JsonFormat : TextFormat
-  end
-
-  class TextFormat < Taski::Task
-    def run
-      @format_report = ->(report) {
-        report.map do |dept, stats|
-          "#{dept}: #{stats[:user_count]} users, $#{stats[:total_sales]} sales"
-        end.join("\n")
-      }
-    end
-  end
-
-  class JsonFormat < Taski::Task
-    def run
-      require "json"
-      @format_report = ->(report) { JSON.pretty_generate(report) }
-    end
-  end
-end
-
-# Transform: Enrich users with sales data
-class EnrichWithSales < Taski::Task
-  exports :users_with_sales
-
-  def run
-    users = DataSourceSection.users
-    sales = DataSourceSection.sales
-
-    sales_by_user = sales.group_by { |s| s[:user_id] }
-      .transform_values { |records| records.sum { |r| r[:amount] } }
-
-    @users_with_sales = users.map do |user|
-      user.merge(total_sales: sales_by_user[user[:id]] || 0)
-    end
-
-    puts "  [EnrichWithSales] Enriched #{@users_with_sales.size} users"
-  end
-end
-
-# Transform: Enrich users with activity data
-class EnrichWithActivities < Taski::Task
-  exports :users_with_activities
-
-  def run
-    users = DataSourceSection.users
-    activities = DataSourceSection.activities
-
-    activities_by_user = activities.group_by { |a| a[:user_id] }
-      .transform_values do |records|
-        records.to_h { |r| [r[:action], r[:count]] }
-    end
-
-    @users_with_activities = users.map do |user|
-      user.merge(activities: activities_by_user[user[:id]] || {})
-    end
-
-    puts "  [EnrichWithActivities] Enriched #{@users_with_activities.size} users"
-  end
-end
-
-# Aggregate: Combine enrichments into profiles
-class BuildProfiles < Taski::Task
-  exports :profiles
-
-  def run
-    users_sales = EnrichWithSales.users_with_sales
-    users_activities = EnrichWithActivities.users_with_activities
-
-    activities_map = users_activities.to_h { |u| [u[:id], u[:activities]] }
-
-    @profiles = users_sales.map do |user|
-      user.merge(activities: activities_map[user[:id]] || {})
-    end
-
-    puts "  [BuildProfiles] Built #{@profiles.size} profiles"
-  end
-end
-
-# Output: Generate department report
-class GenerateReport < Taski::Task
-  exports :report, :formatted_output
-
-  def run
-    profiles = BuildProfiles.profiles
-    formatter = ReportFormatSection.format_report
-
-    by_department = profiles.group_by { |p| p[:department] }
-
-    @report = by_department.transform_values do |dept_users|
-      {
-        user_count: dept_users.size,
-        total_sales: dept_users.sum { |u| u[:total_sales] },
-        total_commits: dept_users.sum { |u| u[:activities][:commit] || 0 },
-        total_reviews: dept_users.sum { |u| u[:activities][:review] || 0 }
-      }
-    end
-
-    @formatted_output = formatter.call(@report)
-    puts "  [GenerateReport] Generated report for #{@report.size} departments"
-  end
-end
-
-# Demo execution
-puts "Taski Data Pipeline Demo"
-puts "=" * 50
-
-puts "\n1. Dependency Tree"
-puts "-" * 50
-puts GenerateReport.tree
-
-puts "\n2. Production Data (default)"
-puts "-" * 50
-ENV["USE_TEST_DATA"] = "false"
-ENV["REPORT_FORMAT"] = "text"
-
-start_time = Time.now
-GenerateReport.run
-elapsed = Time.now - start_time
-
-puts "\nReport (text format):"
-puts GenerateReport.formatted_output
-puts "\nCompleted in #{elapsed.round(3)}s"
-
-puts "\n" + "=" * 50
-puts "\n3. Test Data with JSON Format"
-puts "-" * 50
-ENV["USE_TEST_DATA"] = "true"
-ENV["REPORT_FORMAT"] = "json"
-
-# Reset all tasks for fresh execution
-[DataSourceSection, ReportFormatSection, EnrichWithSales,
-  EnrichWithActivities, BuildProfiles, GenerateReport].each(&:reset!)
-
-start_time = Time.now
-GenerateReport.run
-elapsed = Time.now - start_time
-
-puts "\nReport (JSON format):"
-puts GenerateReport.formatted_output
-puts "\nCompleted in #{elapsed.round(3)}s"
-
-puts "\n" + "=" * 50
-puts "Pipeline demonstration complete!"
-puts "\nKey concepts demonstrated:"
-puts "  - DataSourceSection: Switch between production/test data"
-puts "  - ReportFormatSection: Switch output format (text/JSON)"
-puts "  - Parallel execution of independent transforms"
-puts "\nTo disable progress display:"
-puts "  TASKI_PROGRESS_DISABLE=1 ruby examples/data_pipeline_demo.rb"