taski 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7677c0f3995a7c61b5850fb25c82c60626287584e5c7f918939ededc045e9ea
-  data.tar.gz: d470969c88a4df51503487aacdf2c6261b65e6ed75ee3c7cc2ff744dfd750365
+  metadata.gz: 7c841d7a7a8e632045f42b090be2c6b10a9ef1510c9b9298bc50737f89486f28
+  data.tar.gz: 540f4595d667f191ac2a36464529e324fd56c5a5466dbcc2580b5227030501b5
 SHA512:
-  metadata.gz: 5f93d9e7d10f7104851266f0252ec4365d445a90d3a25b885f289df5d8caafbe9f9250ff9236e4cca0791749100c83c46735a8e98e5c1b675662199ba7a0e547
-  data.tar.gz: eb4fb9f806cdd5097e0d3321d4cda9e3df183d4850c4aa8161ba09b71666444166f05b5e795b330227076d85f7410adbe2fc4f1e2b19c66d007ff1632d354f97
+  metadata.gz: c4b2064e55edde2f504fd8c857efff572faf6de8466983c0081c2ca902c63784c75d121c482691cf24e1b8f80a863c97c2268e358271692967adc5612933da28
+  data.tar.gz: b56270d6324127635290a906bb6d7361a8c9609ad071ea307b26dcd3b16489c073be909e744680b52a202ab99019c611d9a0112cf2b18fc180f8113fb3fcef5a

data/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.1] - 2026-01-26
+
+### Added
+- `Taski.message` API for user-facing output during task execution ([#129](https://github.com/ahogappa/taski/pull/129))
+
+### Fixed
+- Count unselected section candidates as completed in SimpleProgressDisplay ([#128](https://github.com/ahogappa/taski/pull/128))
+- Prioritize environment variable over code settings for progress_mode ([#127](https://github.com/ahogappa/taski/pull/127))
+
 ## [0.8.0] - 2026-01-23
 
 ### Added

data/examples/message_demo.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Demonstrates Taski.message API
+#
+# Taski.message outputs text to the user without being captured by TaskOutputRouter.
+# Messages are queued during progress display and shown after task completion.
+#
+# Usage:
+#   ruby examples/message_demo.rb
+#   TASKI_FORCE_PROGRESS=1 ruby examples/message_demo.rb  # Force progress display
+
+require_relative "../lib/taski"
+
+class ProcessDataTask < Taski::Task
+  exports :processed_count
+
+  def run
+    puts "Starting data processing..."  # Captured by TaskOutputRouter
+
+    # Simulate processing
+    5.times do |i|
+      puts "Processing batch #{i + 1}/5..."  # Captured
+      sleep 0.3
+    end
+
+    @processed_count = 42
+
+    # These messages bypass TaskOutputRouter and appear after execution
+    Taski.message("Created: /tmp/output.txt")
+    Taski.message("Summary: #{@processed_count} items processed successfully")
+  end
+end
+
+class GenerateReportTask < Taski::Task
+  exports :report_path
+
+  def run
+    # Dependency: ProcessDataTask will be executed first
+    count = ProcessDataTask.processed_count
+    puts "Generating report for #{count} items..."  # Captured
+
+    sleep 0.5
+
+    @report_path = "/tmp/report.pdf"
+
+    Taski.message("Report available at: #{@report_path}")
+  end
+end
+
+puts "=== Taski.message Demo ==="
+puts
+
+GenerateReportTask.run
+
+puts
+puts "=== Done ==="

data/lib/taski/execution/execution_context.rb

@@ -81,6 +81,7 @@ module Taski
         @output_capture = nil
         @original_stdout = nil
         @runtime_dependencies = {}
+        @message_queue = []
       end
 
       # Check if output capture is already active.
@@ -89,6 +90,31 @@ module Taski
         @monitor.synchronize { !@output_capture.nil? }
       end
 
+      # Queue a message to be displayed after execution completes.
+      # Thread-safe for access from worker threads.
+      #
+      # @param text [String] The message text to queue
+      def queue_message(text)
+        @monitor.synchronize { @message_queue << text }
+      end
+
+      # Flush all queued messages to the given output.
+      # Clears the queue after flushing.
+      #
+      # @param output [IO] The output stream to write messages to
+      def flush_messages(output)
+        messages = @monitor.synchronize { @message_queue.dup.tap { @message_queue.clear } }
+        messages.each { |msg| output.puts(msg) }
+      end
+
+      # Get the original stdout before output capture was set up.
+      # Thread-safe accessor.
+      #
+      # @return [IO, nil] The original stdout or nil if not captured
+      def original_stdout
+        @monitor.synchronize { @original_stdout }
+      end
+
       # Set up output capture for inline progress display.
       # Creates TaskOutputRouter and replaces $stdout.
       # Should only be called when progress display is active and not already set up.

data/lib/taski/execution/executor.rb

@@ -418,9 +418,17 @@ module Taski
       ensure
         stop_progress_display
         @saved_output_capture = @execution_context.output_capture
+        flush_queued_messages if should_teardown_capture
         teardown_output_capture if should_teardown_capture
       end
 
+      # Flush queued messages from ExecutionContext to original stdout.
+      # Called after progress display stops to show user messages.
+      def flush_queued_messages
+        output = @execution_context.original_stdout || $stdout
+        @execution_context.flush_messages(output)
+      end
+
       def create_default_execution_context
         context = ExecutionContext.new
         progress = Taski.progress_display

data/lib/taski/execution/simple_progress_display.rb

@@ -34,6 +34,7 @@ module Taski
         @spinner_index = 0
         @renderer_thread = nil
         @running = false
+        @section_candidates = {} # section_class => [candidate_classes]
       end
 
       protected
@@ -44,9 +45,18 @@ module Taski
       end
 
       # Template method: Called when a section impl is registered
-      def on_section_impl_registered(_section_class, impl_class)
+      def on_section_impl_registered(section_class, impl_class)
         @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
       end
 
       # Template method: Determine if display should activate
@@ -83,6 +93,23 @@ module Taski
         # Use TreeProgressDisplay's static method for tree building
         tree = TreeProgressDisplay.build_tree_node(@root_task_class)
         register_tasks_from_tree(tree)
+        collect_section_candidates(tree)
+      end
+
+      def collect_section_candidates(node)
+        return unless node
+
+        task_class = node[:task_class]
+
+        # If this is a section, collect its implementation candidates
+        if node[:is_section]
+          candidates = node[:children]
+            .select { |c| c[:is_impl_candidate] }
+            .map { |c| c[:task_class] }
+          @section_candidates[task_class] = candidates unless candidates.empty?
+        end
+
+        node[:children].each { |child| collect_section_candidates(child) }
       end
 
       def render_live

data/lib/taski/version.rb

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

data/lib/taski.rb

@@ -140,6 +140,7 @@ module Taski
 
   @args_monitor = Monitor.new
   @env_monitor = Monitor.new
+  @message_monitor = Monitor.new
 
   # Get the current runtime arguments
   # @return [Args, nil] The current args or nil if no task is running
@@ -153,6 +154,23 @@ module Taski
     @env_monitor.synchronize { @env }
   end
 
+  # Output a message to the user without being captured by TaskOutputRouter.
+  # During task execution with progress display, messages are queued and
+  # displayed after execution completes. Without progress display or outside
+  # task execution, messages are output immediately.
+  #
+  # @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)
+      else
+        $stdout.puts(text)
+      end
+    end
+  end
+
   # Start new execution environment (internal use only)
   # @api private
   # @return [Boolean] true if this call created the env, false if env already existed
@@ -229,9 +247,14 @@ module Taski
   end
 
   # Get the current progress mode (:tree or :simple)
+  # Environment variable TASKI_PROGRESS_MODE takes precedence over code settings.
   # @return [Symbol] The current progress mode
   def self.progress_mode
-    @progress_mode || progress_mode_from_env
+    if ENV["TASKI_PROGRESS_MODE"]
+      progress_mode_from_env
+    else
+      @progress_mode || :tree
+    end
   end
 
   # Set the progress mode (:tree or :simple)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taski
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - ahogappa
@@ -62,6 +62,7 @@ files:
 - 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/quick_start.rb
@@ -120,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.4
 specification_version: 4
 summary: A simple yet powerful Ruby task runner with static dependency resolution
   (in development).