taski 0.8.3 → 0.9.1

data/examples/clean_demo.rb

@@ -6,7 +6,7 @@
 # This example demonstrates the clean functionality:
 # - Defining clean methods for resource cleanup
 # - Reverse dependency order execution (dependents cleaned before dependencies)
-# - Parallel clean execution when possible
+# - run_and_clean with block support
 #
 # Run: ruby examples/clean_demo.rb
 
@@ -22,24 +22,14 @@ BUILD_DIR = "/tmp/taski_clean_demo"
 class SetupBuildDir < Taski::Task
   exports :build_path
 
-  ##
-  # Prepares the task's build directory and simulates its creation.
-  #
-  # Sets the task's exported `build_path` to the "build" subdirectory under `BUILD_DIR`
-  # and performs a simulated creation step with informational output.
   def run
     @build_path = "#{BUILD_DIR}/build"
     puts "[SetupBuildDir] Creating build directory: #{@build_path}"
-    # Simulated directory creation
     sleep 0.8
   end
 
-  ##
-  # Removes the directory referenced by @build_path.
-  # Cleans up build artifacts created by this task.
   def clean
     puts "[SetupBuildDir] Removing build directory: #{@build_path}"
-    # Simulated directory removal
     sleep 0.8
   end
 end
@@ -48,9 +38,6 @@ end
 class CompileSource < Taski::Task
   exports :binary_path
 
-  ##
-  # Compiles source artifacts and sets the compiled binary path for downstream tasks.
-  # This method sets @binary_path to the build directory's "app.bin" file and emits a console message indicating the compilation target.
   def run
     build_dir = SetupBuildDir.build_path
     @binary_path = "#{build_dir}/app.bin"
@@ -58,9 +45,6 @@ class CompileSource < Taski::Task
     sleep 1.5
   end
 
-  ##
-  # Removes the compiled binary produced by this task.
-  # Performs the task's cleanup step and simulates the deletion process.
   def clean
     puts "[CompileSource] Removing compiled binary: #{@binary_path}"
     sleep 0.6
@@ -71,11 +55,6 @@ end
 class GenerateDocs < Taski::Task
   exports :docs_path
 
-  ##
-  # Generates documentation for the build and records the output path.
-  #
-  # Sets the task's `@docs_path` to the "docs" subdirectory under `SetupBuildDir.build_path`
-  # and prints a progress message to STDOUT.
   def run
     build_dir = SetupBuildDir.build_path
     @docs_path = "#{build_dir}/docs"
@@ -83,9 +62,6 @@ class GenerateDocs < Taski::Task
     sleep 1.2
   end
 
-  ##
-  # Removes the generated documentation at the task's docs_path.
-  # Prints a removal message for @docs_path and simulates its deletion.
   def clean
     puts "[GenerateDocs] Removing generated docs: #{@docs_path}"
     sleep 0.5
@@ -96,9 +72,6 @@ end
 class CreateRelease < Taski::Task
   exports :release_path
 
-  ##
-  # Creates the release package path and announces the included artifacts.
-  # Uses CompileSource.binary_path and GenerateDocs.docs_path to determine the package inputs, sets @release_path to "#{BUILD_DIR}/release.zip", and prints the binary, docs, and output paths.
   def run
     binary = CompileSource.binary_path
     docs = GenerateDocs.docs_path
@@ -110,9 +83,6 @@ class CreateRelease < Taski::Task
     sleep 0.7
   end
 
-  ##
-  # Removes the release package produced by this task.
-  # Uses the task's `@release_path` as the target for cleanup.
   def clean
     puts "[CreateRelease] Removing release package: #{@release_path}"
     sleep 0.5
@@ -123,54 +93,44 @@ puts "\n--- Task Tree Structure ---"
 puts CreateRelease.tree
 puts
 
-puts "--- Running build process ---"
-CreateRelease.run
+puts "--- run_and_clean Demo ---"
+puts "The run_and_clean method executes both phases in a single operation."
+puts "Key benefits:"
+puts "  - Single progress display session for both phases"
+puts "  - Clean always runs, even if run fails (resource release)"
+puts "  - Cleaner API for the common use case"
 puts
 
-puts "Build completed!"
-puts "  Release: #{CreateRelease.release_path}"
-puts
+CreateRelease.run_and_clean
 
-puts "--- Cleaning up (reverse dependency order) ---"
-puts "Note: CreateRelease cleans first, then CompileSource/GenerateDocs in parallel,"
-puts "      and finally SetupBuildDir cleans last."
+puts
+puts "Both run and clean phases completed in a single call!"
 puts
 
-# Reset to allow clean execution
+# Demonstrate block support
 Taski::Task.reset!
 
-# Re-run to set up state for clean
-CreateRelease.run
-
-puts "\nNow cleaning..."
-CreateRelease.clean
-
-puts
-puts "Clean completed! All artifacts removed."
-
-puts
 puts "=" * 40
-puts "run_and_clean Demo"
+puts "run_and_clean with Block Demo"
 puts "=" * 40
 puts
-puts "The run_and_clean method executes both phases in a single operation."
-puts "Key benefits:"
-puts "  - Single progress display session for both phases"
-puts "  - Clean always runs, even if run fails (resource release)"
-puts "  - Cleaner API for the common use case"
+puts "Use a block to execute code between run and clean phases."
+puts "Exported values are accessible within the block."
 puts
 
-# Reset for new demonstration
-Taski::Task.reset!
-
-puts "--- Using run_and_clean ---"
-puts "This is equivalent to calling run followed by clean, but in a single operation."
-puts
-
-CreateRelease.run_and_clean
+CreateRelease.run_and_clean do
+  puts
+  puts "[Block] Release created at: #{CreateRelease.release_path}"
+  puts "[Block] Binary: #{CompileSource.binary_path}"
+  puts "[Block] Docs: #{GenerateDocs.docs_path}"
+  puts "[Block] Deploying release..."
+  sleep 0.3
+  puts "[Block] Deploy complete!"
+  puts
+end
 
 puts
-puts "Both run and clean phases completed in a single call!"
+puts "Block executed between run and clean phases!"
 puts
 
 # Demonstrate error handling

data/examples/large_tree_demo.rb

@@ -0,0 +1,356 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Demo: Large tree to test rendering performance
+# Run with: ruby examples/large_tree_demo.rb
+
+require_relative "../lib/taski"
+
+# Leaf tasks (Layer 4) - 16 tasks
+class Leaf01 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf01: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf01: Done!"
+    @value = "leaf01"
+  end
+end
+
+class Leaf02 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf02: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf02: Done!"
+    @value = "leaf02"
+  end
+end
+
+class Leaf03 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf03: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf03: Done!"
+    @value = "leaf03"
+  end
+end
+
+class Leaf04 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf04: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf04: Done!"
+    @value = "leaf04"
+  end
+end
+
+class Leaf05 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf05: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf05: Done!"
+    @value = "leaf05"
+  end
+end
+
+class Leaf06 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf06: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf06: Done!"
+    @value = "leaf06"
+  end
+end
+
+class Leaf07 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf07: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf07: Done!"
+    @value = "leaf07"
+  end
+end
+
+class Leaf08 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf08: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf08: Done!"
+    @value = "leaf08"
+  end
+end
+
+class Leaf09 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf09: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf09: Done!"
+    @value = "leaf09"
+  end
+end
+
+class Leaf10 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf10: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf10: Done!"
+    @value = "leaf10"
+  end
+end
+
+class Leaf11 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf11: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf11: Done!"
+    @value = "leaf11"
+  end
+end
+
+class Leaf12 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf12: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf12: Done!"
+    @value = "leaf12"
+  end
+end
+
+class Leaf13 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf13: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf13: Done!"
+    @value = "leaf13"
+  end
+end
+
+class Leaf14 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf14: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf14: Done!"
+    @value = "leaf14"
+  end
+end
+
+class Leaf15 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf15: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf15: Done!"
+    @value = "leaf15"
+  end
+end
+
+class Leaf16 < Taski::Task
+  exports :value
+  def run
+    puts "Leaf16: Starting..."
+    sleep(rand(0.1..0.3))
+    puts "Leaf16: Done!"
+    @value = "leaf16"
+  end
+end
+
+# Middle tasks (Layer 3) - 8 tasks, each depends on 2 leaves
+class Middle01 < Taski::Task
+  exports :value
+  def run
+    puts "Middle01: Aggregating leaves..."
+    Leaf01.value
+    Leaf02.value
+    sleep(0.05)
+    puts "Middle01: Complete"
+    @value = "middle01"
+  end
+end
+
+class Middle02 < Taski::Task
+  exports :value
+  def run
+    puts "Middle02: Aggregating leaves..."
+    Leaf03.value
+    Leaf04.value
+    sleep(0.05)
+    puts "Middle02: Complete"
+    @value = "middle02"
+  end
+end
+
+class Middle03 < Taski::Task
+  exports :value
+  def run
+    puts "Middle03: Aggregating leaves..."
+    Leaf05.value
+    Leaf06.value
+    sleep(0.05)
+    puts "Middle03: Complete"
+    @value = "middle03"
+  end
+end
+
+class Middle04 < Taski::Task
+  exports :value
+  def run
+    puts "Middle04: Aggregating leaves..."
+    Leaf07.value
+    Leaf08.value
+    sleep(0.05)
+    puts "Middle04: Complete"
+    @value = "middle04"
+  end
+end
+
+class Middle05 < Taski::Task
+  exports :value
+  def run
+    puts "Middle05: Aggregating leaves..."
+    Leaf09.value
+    Leaf10.value
+    sleep(0.05)
+    puts "Middle05: Complete"
+    @value = "middle05"
+  end
+end
+
+class Middle06 < Taski::Task
+  exports :value
+  def run
+    puts "Middle06: Aggregating leaves..."
+    Leaf11.value
+    Leaf12.value
+    sleep(0.05)
+    puts "Middle06: Complete"
+    @value = "middle06"
+  end
+end
+
+class Middle07 < Taski::Task
+  exports :value
+  def run
+    puts "Middle07: Aggregating leaves..."
+    Leaf13.value
+    Leaf14.value
+    sleep(0.05)
+    puts "Middle07: Complete"
+    @value = "middle07"
+  end
+end
+
+class Middle08 < Taski::Task
+  exports :value
+  def run
+    puts "Middle08: Aggregating leaves..."
+    Leaf15.value
+    Leaf16.value
+    sleep(0.05)
+    puts "Middle08: Complete"
+    @value = "middle08"
+  end
+end
+
+# Top tasks (Layer 2) - 4 tasks, each depends on 2 middles
+class Top01 < Taski::Task
+  exports :value
+  def run
+    Middle01.value
+    Middle02.value
+    sleep(0.05)
+    @value = "top01"
+  end
+end
+
+class Top02 < Taski::Task
+  exports :value
+  def run
+    Middle03.value
+    Middle04.value
+    sleep(0.05)
+    @value = "top02"
+  end
+end
+
+class Top03 < Taski::Task
+  exports :value
+  def run
+    Middle05.value
+    Middle06.value
+    sleep(0.05)
+    @value = "top03"
+  end
+end
+
+class Top04 < Taski::Task
+  exports :value
+  def run
+    Middle07.value
+    Middle08.value
+    sleep(0.05)
+    @value = "top04"
+  end
+end
+
+# Branch tasks (Layer 1) - 2 tasks, each depends on 2 tops
+class Branch01 < Taski::Task
+  exports :value
+  def run
+    Top01.value
+    Top02.value
+    sleep(0.05)
+    @value = "branch01"
+  end
+end
+
+class Branch02 < Taski::Task
+  exports :value
+  def run
+    Top03.value
+    Top04.value
+    sleep(0.05)
+    @value = "branch02"
+  end
+end
+
+# Root task (Layer 0)
+class LargeTreeRoot < Taski::Task
+  exports :result
+
+  def run
+    Branch01.value
+    Branch02.value
+    sleep(0.05)
+    @result = "done"
+  end
+end
+
+puts "Large Tree Demo"
+puts "==============="
+puts "Tree structure: 1 root -> 2 branch -> 4 top -> 8 middle -> 16 leaf (31 total)"
+puts
+puts "Static tree:"
+puts LargeTreeRoot.tree
+puts
+puts "Running with progress display..."
+puts
+
+Taski.progress_display = Taski::Progress::Layout::Tree.new
+LargeTreeRoot.reset!
+result = LargeTreeRoot.result
+
+puts
+puts "Result: #{result}"

data/examples/message_demo.rb

@@ -8,7 +8,6 @@
 #
 # Usage:
 #   ruby examples/message_demo.rb
-#   TASKI_FORCE_PROGRESS=1 ruby examples/message_demo.rb  # Force progress display
 
 require_relative "../lib/taski"
 

data/examples/progress_demo.rb

@@ -4,13 +4,11 @@
 # Taski Progress Display Demo
 #
 # This example demonstrates the progress display modes:
-# - Tree mode (default): Shows task hierarchy with real-time updates
-# - Simple mode: One-line spinner with current task name
+# - Simple mode (default): One-line spinner with current task name
+# - Tree mode: Shows task hierarchy with real-time updates
 #
 # Run:
-#   ruby examples/progress_demo.rb              # Tree mode (default)
-#   TASKI_PROGRESS_MODE=simple ruby examples/progress_demo.rb  # Simple mode
-#   TASKI_PROGRESS_DISABLE=1 ruby examples/progress_demo.rb    # No progress
+#   ruby examples/progress_demo.rb              # Simple mode (default)
 #
 # Covers:
 # - Parallel task execution with progress display
@@ -20,24 +18,16 @@
 
 require_relative "../lib/taski"
 
-# Configuration section with multiple implementations
-class DatabaseSection < Taski::Section
-  interfaces :connection_string
+# Configuration task with conditional logic
+class DatabaseConfig < Taski::Task
+  exports :connection_string
 
-  def impl
-    (ENV["USE_PROD_DB"] == "1") ? ProductionDB : DevelopmentDB
-  end
-
-  class ProductionDB < Taski::Task
-    def run
+  def run
+    if ENV["USE_PROD_DB"] == "1"
       puts "Connecting to production database..."
       sleep(0.4)
       @connection_string = "postgresql://prod-server:5432/myapp"
-    end
-  end
-
-  class DevelopmentDB < Taski::Task
-    def run
+    else
       puts "Connecting to development database..."
       sleep(0.3)
       @connection_string = "postgresql://localhost:5432/myapp_dev"
@@ -109,7 +99,7 @@ class BuildApplication < Taski::Task
   exports :result
 
   def run
-    db = DatabaseSection.connection_string
+    db = DatabaseConfig.connection_string
     layers = ExtractLayers.extracted_data
     RunSystemCommand.command_result
 
@@ -129,7 +119,7 @@ end
 # Main execution
 puts "Taski Progress Display Demo"
 puts "=" * 50
-puts "Progress mode: #{Taski.progress_mode || "tree (default)"}"
+puts "Progress display: #{Taski.progress_display.class}"
 puts
 
 puts "Task Tree Structure:"
@@ -149,6 +139,5 @@ puts "=" * 50
 puts "Execution completed!"
 puts "Result: #{result.inspect}"
 puts
-puts "Try different modes:"
-puts "  TASKI_PROGRESS_MODE=simple ruby examples/progress_demo.rb"
-puts "  TASKI_PROGRESS_DISABLE=1 ruby examples/progress_demo.rb"
+puts "To use tree mode, add before execution:"
+puts "  Taski.progress_display = Taski::Progress::Layout::Tree.new"

data/examples/reexecution_demo.rb

@@ -5,10 +5,9 @@
 #
 # This example demonstrates the execution model:
 # - Task.run / Task.value: Fresh execution every time
-# - Task.new.run: Instance-level caching
 # - Dependencies within same execution scope share results
 #
-# Run: TASKI_PROGRESS_DISABLE=1 ruby examples/reexecution_demo.rb
+# Run: ruby examples/reexecution_demo.rb
 
 require_relative "../lib/taski"
 
@@ -65,37 +64,7 @@ puts "  => #{value2}"
 puts "\nValues are different: #{value1 != value2}"
 
 puts "\n" + "=" * 50
-puts "\n2. Task.new: Instance-Level Caching"
-puts "-" * 50
-puts "Same instance caches the result:"
-
-instance = RandomGenerator.new
-puts "\nFirst run on instance:"
-result1 = instance.run
-puts "  instance.value = #{instance.value}"
-
-puts "\nSecond run on same instance (returns cached):"
-result2 = instance.run
-puts "  instance.value = #{instance.value}"
-
-puts "\nSame result: #{result1 == result2}"
-
-puts "\n" + "=" * 50
-puts "\n3. Different Instances: Independent Executions"
-puts "-" * 50
-
-instance1 = RandomGenerator.new
-instance1.run
-puts "instance1.value = #{instance1.value}"
-
-instance2 = RandomGenerator.new
-instance2.run
-puts "instance2.value = #{instance2.value}"
-
-puts "\nDifferent values: #{instance1.value != instance2.value}"
-
-puts "\n" + "=" * 50
-puts "\n4. Scope-Based Caching for Dependencies"
+puts "\n2. Scope-Based Caching for Dependencies"
 puts "-" * 50
 puts "Within ONE execution, dependencies are cached:"
 
@@ -106,7 +75,7 @@ puts "\nNote: Both accesses return the SAME value!"
 puts "(Because they're in the same execution scope)"
 
 puts "\n" + "=" * 50
-puts "\n5. Dependency Chain with Fresh Execution"
+puts "\n3. Dependency Chain with Fresh Execution"
 puts "-" * 50
 
 puts "Each Consumer.run creates fresh RandomGenerator:"
@@ -117,7 +86,7 @@ puts "\nSecond Consumer.run (different RandomGenerator value):"
 Consumer.run
 
 puts "\n" + "=" * 50
-puts "\n6. Use Cases Summary"
+puts "\n4. Use Cases Summary"
 puts "-" * 50
 puts <<~SUMMARY
   TaskClass.run / TaskClass.value
@@ -125,15 +94,10 @@ puts <<~SUMMARY
     => Dependencies within same execution are cached
     => Use for: Independent executions, scripts
 
-  TaskClass.new.run
-    => Instance caches results
-    => Multiple .run calls return cached value
-    => Use for: Re-execution control, testing
-
-  instance.reset!
-    => Clears instance cache
-    => Next .run will execute fresh
-    => Use for: Re-running same instance
+  TaskClass.reset!
+    => Clears task state
+    => Next execution starts fresh
+    => Use for: Re-running tasks in tests
 SUMMARY
 
 puts "\n" + "=" * 50