taski 0.8.2 → 0.9.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taski
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.9.0
 platform: ruby
 authors:
 - ahogappa
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: liquid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: prism
   requirement: !ruby/object:Gem::Requirement
@@ -60,27 +74,36 @@ files:
 - examples/args_demo.rb
 - examples/clean_demo.rb
 - examples/group_demo.rb
+- examples/large_tree_demo.rb
 - examples/message_demo.rb
 - examples/progress_demo.rb
 - examples/quick_start.rb
 - examples/reexecution_demo.rb
-- examples/section_demo.rb
 - lib/taski.rb
 - lib/taski/args.rb
 - lib/taski/env.rb
-- lib/taski/execution/base_progress_display.rb
-- lib/taski/execution/execution_context.rb
+- lib/taski/execution/execution_facade.rb
 - lib/taski/execution/executor.rb
-- lib/taski/execution/plain_progress_display.rb
 - lib/taski/execution/registry.rb
 - lib/taski/execution/scheduler.rb
-- lib/taski/execution/simple_progress_display.rb
+- lib/taski/execution/task_observer.rb
 - lib/taski/execution/task_output_pipe.rb
 - lib/taski/execution/task_output_router.rb
 - lib/taski/execution/task_wrapper.rb
-- lib/taski/execution/tree_progress_display.rb
 - lib/taski/execution/worker_pool.rb
-- lib/taski/section.rb
+- lib/taski/logging.rb
+- lib/taski/progress/layout/base.rb
+- lib/taski/progress/layout/filters.rb
+- lib/taski/progress/layout/log.rb
+- lib/taski/progress/layout/simple.rb
+- lib/taski/progress/layout/tags.rb
+- lib/taski/progress/layout/theme_drop.rb
+- lib/taski/progress/layout/tree.rb
+- lib/taski/progress/theme/base.rb
+- lib/taski/progress/theme/compact.rb
+- lib/taski/progress/theme/default.rb
+- lib/taski/progress/theme/detail.rb
+- lib/taski/progress/theme/plain.rb
 - lib/taski/static_analysis/analyzer.rb
 - lib/taski/static_analysis/dependency_graph.rb
 - lib/taski/static_analysis/visitor.rb

data/examples/section_demo.rb

@@ -1,195 +0,0 @@
-#!/usr/bin/env ruby
-
-# Section API Basics Example
-# This example demonstrates runtime implementation selection with the Section API
-
-# Section API is perfect for:
-# - Environment-specific implementations (dev/staging/prod)
-# - Different service adapters (AWS/GCP/local)
-# - Clean abstraction with guaranteed interfaces
-
-require_relative "../lib/taski"
-
-# Example 1: Database Configuration Section
-# This section provides database configuration with different implementations
-# for development and production environments
-class DatabaseSection < Taski::Section
-  # Define the interface that implementations must provide
-  interfaces :host, :port, :username, :password, :database_name, :pool_size
-
-  # Select implementation based on environment
-  # Note: Must return a Task class - .run is automatically called
-  # No 'self' needed - just define as instance method!
-  def impl
-    if ENV["RAILS_ENV"] == "production"
-      Production
-    else
-      Development
-    end
-  end
-
-  # Production implementation with secure settings
-  # No exports needed - automatically inherited from interfaces
-  class Production < Taski::Task
-    def run
-      @host = "prod-db.example.com"
-      @port = 5432
-      @username = "app_user"
-      @password = ENV["DB_PASSWORD"] || "secure_password"
-      @database_name = "myapp_production"
-      @pool_size = 25
-    end
-  end
-
-  # Development implementation with local settings
-  class Development < Taski::Task
-    def run
-      @host = "localhost"
-      @port = 5432
-      @username = "dev_user"
-      @password = "dev_password"
-      @database_name = "myapp_development"
-      @pool_size = 5
-    end
-  end
-end
-
-# Example 2: API Configuration Section
-# This section provides API endpoints and credentials
-class ApiSection < Taski::Section
-  interfaces :base_url, :api_key, :timeout, :retry_count
-
-  # No 'self' needed - just define as instance method!
-  def impl
-    # Select based on feature flag
-    # Note: Must return a Task class - .run is automatically called
-    if ENV["USE_STAGING_API"] == "true"
-      Staging
-    else
-      Production
-    end
-  end
-
-  class Production < Taski::Task
-    def run
-      @base_url = "https://api.example.com/v1"
-      @api_key = ENV["PROD_API_KEY"] || "prod-key-123"
-      @timeout = 30
-      @retry_count = 3
-    end
-  end
-
-  class Staging < Taski::Task
-    def run
-      @base_url = "https://staging-api.example.com/v1"
-      @api_key = ENV["STAGING_API_KEY"] || "staging-key-456"
-      @timeout = 60
-      @retry_count = 1
-    end
-  end
-end
-
-# Example 3: Task that depends on multiple sections
-class ApplicationSetup < Taski::Task
-  exports :config_summary
-
-  def run
-    puts "Setting up application with configuration:"
-    puts "Database: #{DatabaseSection.host}:#{DatabaseSection.port}/#{DatabaseSection.database_name}"
-    puts "API: #{ApiSection.base_url}"
-    puts "Pool size: #{DatabaseSection.pool_size}"
-    puts "API timeout: #{ApiSection.timeout}s"
-
-    @config_summary = {
-      database: {
-        host: DatabaseSection.host,
-        port: DatabaseSection.port,
-        database: DatabaseSection.database_name,
-        pool_size: DatabaseSection.pool_size
-      },
-      api: {
-        base_url: ApiSection.base_url,
-        timeout: ApiSection.timeout,
-        retry_count: ApiSection.retry_count
-      }
-    }
-  end
-end
-
-# Example 4: Complex dependency chain with sections
-class DatabaseConnection < Taski::Task
-  exports :connection
-
-  def run
-    puts "Connecting to database..."
-    # Use section configuration to create connection
-    connection_string = "postgresql://#{DatabaseSection.username}:#{DatabaseSection.password}@#{DatabaseSection.host}:#{DatabaseSection.port}/#{DatabaseSection.database_name}"
-    @connection = "Connected to: #{connection_string} (pool: #{DatabaseSection.pool_size})"
-    puts @connection
-  end
-end
-
-class ApiClient < Taski::Task
-  exports :client
-
-  def run
-    puts "Initializing API client..."
-    @client = "API Client: #{ApiSection.base_url} (timeout: #{ApiSection.timeout}s, retries: #{ApiSection.retry_count})"
-    puts @client
-  end
-end
-
-class Application < Taski::Task
-  def run
-    puts "\n=== Starting Application ==="
-
-    # Dependencies are automatically resolved
-    # DatabaseConnection and ApiClient will be executed first
-    # which triggers execution of their respective sections
-
-    puts "\nDatabase ready: #{DatabaseConnection.connection}"
-    puts "API ready: #{ApiClient.client}"
-
-    puts "\nApplication configuration summary:"
-    puts ApplicationSetup.config_summary.inspect
-
-    puts "\n=== Application Started Successfully ==="
-  end
-end
-
-puts "Taski Section Configuration Example"
-puts "=" * 50
-
-puts "\n1. Development Environment (default)"
-ENV["RAILS_ENV"] = "development"
-ENV["USE_STAGING_API"] = "false"
-
-# Reset all tasks to ensure fresh build
-[DatabaseSection, ApiSection, ApplicationSetup, DatabaseConnection, ApiClient, Application].each(&:reset!)
-
-Application.run
-
-puts "\n" + "=" * 50
-puts "\n2. Production Environment with Staging API"
-ENV["RAILS_ENV"] = "production"
-ENV["USE_STAGING_API"] = "true"
-
-# Reset all tasks to see different configuration
-[DatabaseSection, ApiSection, ApplicationSetup, DatabaseConnection, ApiClient, Application].each(&:reset!)
-
-Application.run
-
-puts "\n" + "=" * 50
-puts "\n3. Dependency Tree Visualization"
-puts "\nApplication dependency tree:"
-puts Application.tree
-
-puts "\nDatabaseConnection dependency tree:"
-puts DatabaseConnection.tree
-
-puts "\nApiClient dependency tree:"
-puts ApiClient.tree
-
-puts "\n" + "=" * 50
-puts "\nSection dependency resolution successfully demonstrated!"
-puts "Notice how sections appear in the dependency trees and logs."

data/lib/taski/execution/base_progress_display.rb

@@ -1,364 +0,0 @@
-# frozen_string_literal: true
-
-require "monitor"
-
-module Taski
-  module Execution
-    # Base class for progress display implementations.
-    # Provides common task tracking and lifecycle management.
-    # Subclasses override template methods for custom rendering.
-    class BaseProgressDisplay
-      # Shared task progress tracking
-      class TaskProgress
-        # Run lifecycle tracking
-        attr_accessor :run_state, :run_start_time, :run_end_time, :run_error, :run_duration
-        # Clean lifecycle tracking
-        attr_accessor :clean_state, :clean_start_time, :clean_end_time, :clean_error, :clean_duration
-        # Display properties
-        attr_accessor :is_impl_candidate
-        # Group tracking
-        attr_accessor :groups, :current_group_index
-
-        def initialize
-          # Run lifecycle
-          @run_state = :pending
-          @run_start_time = nil
-          @run_end_time = nil
-          @run_error = nil
-          @run_duration = nil
-          # Clean lifecycle
-          @clean_state = nil # nil means clean hasn't started
-          @clean_start_time = nil
-          @clean_end_time = nil
-          @clean_error = nil
-          @clean_duration = nil
-          # Display
-          @is_impl_candidate = false
-          # Groups
-          @groups = []
-          @current_group_index = nil
-        end
-
-        # Returns the most relevant state for display
-        def state
-          @clean_state || @run_state
-        end
-
-        # Legacy accessors for backward compatibility
-        def start_time
-          @clean_start_time || @run_start_time
-        end
-
-        def end_time
-          @clean_end_time || @run_end_time
-        end
-
-        def error
-          @clean_error || @run_error
-        end
-
-        def duration
-          @clean_duration || @run_duration
-        end
-      end
-
-      # Tracks the progress of a group within a task
-      class GroupProgress
-        attr_accessor :name, :state, :start_time, :end_time, :duration, :error, :last_message
-
-        def initialize(name)
-          @name = name
-          @state = :pending
-          @start_time = nil
-          @end_time = nil
-          @duration = nil
-          @error = nil
-          @last_message = nil
-        end
-      end
-
-      def initialize(output: $stdout)
-        @output = output
-        @tasks = {}
-        @monitor = Monitor.new
-        @nest_level = 0
-        @root_task_class = nil
-        @output_capture = nil
-        @start_time = nil
-        @message_queue = []
-      end
-
-      # Set the output capture for getting task output
-      # @param capture [ThreadOutputCapture] The output capture instance
-      def set_output_capture(capture)
-        @monitor.synchronize do
-          @output_capture = capture
-        end
-      end
-
-      # Set the root task to build tree structure
-      # Only sets root task if not already set (prevents nested executor overwrite)
-      # @param root_task_class [Class] The root task class
-      def set_root_task(root_task_class)
-        @monitor.synchronize do
-          return if @root_task_class # Don't overwrite existing root task
-          @root_task_class = root_task_class
-          on_root_task_set
-        end
-      end
-
-      # Register which impl was selected for a section
-      # @param section_class [Class] The section class
-      # @param impl_class [Class] The selected implementation class
-      def register_section_impl(section_class, impl_class)
-        @monitor.synchronize do
-          on_section_impl_registered(section_class, impl_class)
-        end
-      end
-
-      # @param task_class [Class] The task class to register
-      def register_task(task_class)
-        @monitor.synchronize do
-          return if @tasks.key?(task_class)
-          @tasks[task_class] = TaskProgress.new
-          on_task_registered(task_class)
-        end
-      end
-
-      # @param task_class [Class] The task class to check
-      # @return [Boolean] true if the task is registered
-      def task_registered?(task_class)
-        @monitor.synchronize do
-          @tasks.key?(task_class)
-        end
-      end
-
-      # @param task_class [Class] The task class to update
-      # @param state [Symbol] The new state
-      # @param duration [Float] Duration in milliseconds (for completed tasks)
-      # @param error [Exception] Error object (for failed tasks)
-      def update_task(task_class, state:, duration: nil, error: nil)
-        @monitor.synchronize do
-          progress = @tasks[task_class]
-          # Register task if not already registered (for late-registered tasks)
-          progress ||= @tasks[task_class] = TaskProgress.new
-
-          apply_state_transition(progress, state, duration, error)
-          on_task_updated(task_class, state, duration, error)
-        end
-      end
-
-      # @param task_class [Class] The task class
-      # @return [Symbol] The task state
-      def task_state(task_class)
-        @monitor.synchronize do
-          @tasks[task_class]&.state
-        end
-      end
-
-      # Update group state for a task.
-      # @param task_class [Class] The task class containing the group
-      # @param group_name [String] The name of the group
-      # @param state [Symbol] The new state (:running, :completed, :failed)
-      # @param duration [Float, nil] Duration in milliseconds (for completed groups)
-      # @param error [Exception, nil] Error object (for failed groups)
-      def update_group(task_class, group_name, state:, duration: nil, error: nil)
-        @monitor.synchronize do
-          progress = @tasks[task_class]
-          return unless progress
-
-          apply_group_state_transition(progress, group_name, state, duration, error)
-          on_group_updated(task_class, group_name, state, duration, error)
-        end
-      end
-
-      def start
-        should_start = false
-        @monitor.synchronize do
-          @nest_level += 1
-          return if @nest_level > 1 # Already running from outer executor
-          return unless should_activate?
-
-          @start_time = Time.now
-          should_start = true
-        end
-
-        return unless should_start
-
-        on_start
-      end
-
-      def stop
-        should_stop = false
-        @monitor.synchronize do
-          @nest_level -= 1 if @nest_level > 0
-          return unless @nest_level == 0
-
-          should_stop = true
-        end
-
-        return unless should_stop
-
-        on_stop
-        flush_queued_messages
-      end
-
-      # Queue a message to be displayed after progress display stops.
-      # Thread-safe for concurrent task execution.
-      # @param text [String] The message text to queue
-      def queue_message(text)
-        @monitor.synchronize { @message_queue << text }
-      end
-
-      protected
-
-      # Template methods - override in subclasses
-
-      # Called when root task is set. Override to build tree structure.
-      def on_root_task_set
-        # Default: no-op
-      end
-
-      # Called when a section impl is registered.
-      def on_section_impl_registered(section_class, impl_class)
-        # Default: no-op
-      end
-
-      # Called when a task is registered.
-      def on_task_registered(task_class)
-        # Default: no-op
-      end
-
-      # Called when a task state is updated.
-      def on_task_updated(task_class, state, duration, error)
-        # Default: no-op
-      end
-
-      # Called when a group state is updated.
-      def on_group_updated(task_class, group_name, state, duration, error)
-        # Default: no-op
-      end
-
-      # Called to determine if display should activate.
-      # @return [Boolean] true if display should start
-      def should_activate?
-        true
-      end
-
-      # Called when display starts.
-      def on_start
-        # Default: no-op
-      end
-
-      # Called when display stops.
-      def on_stop
-        # Default: no-op
-      end
-
-      # Shared tree traversal for subclasses
-
-      # Register all tasks from a tree structure recursively
-      def register_tasks_from_tree(node)
-        return unless node
-
-        task_class = node[:task_class]
-        @tasks[task_class] ||= TaskProgress.new
-        @tasks[task_class].is_impl_candidate = true if node[:is_impl_candidate]
-
-        node[:children].each { |child| register_tasks_from_tree(child) }
-      end
-
-      # Utility methods for subclasses
-
-      # Get short name of a task class
-      def short_name(task_class)
-        return "Unknown" unless task_class
-        task_class.name&.split("::")&.last || task_class.to_s
-      end
-
-      # Format duration for display
-      def format_duration(ms)
-        if ms >= 1000
-          "#{(ms / 1000.0).round(1)}s"
-        else
-          "#{ms.round(1)}ms"
-        end
-      end
-
-      # Check if output is a TTY
-      def tty?
-        @output.tty?
-      end
-
-      private
-
-      # Flush all queued messages to output.
-      # Called when progress display stops.
-      def flush_queued_messages
-        messages = @monitor.synchronize { @message_queue.dup.tap { @message_queue.clear } }
-        messages.each { |msg| @output.puts(msg) }
-      end
-
-      # Apply state transition to TaskProgress
-      def apply_state_transition(progress, state, duration, error)
-        case state
-        # Run lifecycle states
-        when :pending
-          progress.run_state = :pending
-        when :running
-          progress.run_state = :running
-          progress.run_start_time = Time.now
-        when :completed
-          progress.run_state = :completed
-          progress.run_end_time = Time.now
-          progress.run_duration = duration if duration
-        when :failed
-          progress.run_state = :failed
-          progress.run_end_time = Time.now
-          progress.run_error = error if error
-        # Clean lifecycle states
-        when :cleaning
-          progress.clean_state = :cleaning
-          progress.clean_start_time = Time.now
-        when :clean_completed
-          progress.clean_state = :clean_completed
-          progress.clean_end_time = Time.now
-          progress.clean_duration = duration if duration
-        when :clean_failed
-          progress.clean_state = :clean_failed
-          progress.clean_end_time = Time.now
-          progress.clean_error = error if error
-        end
-      end
-
-      # Apply state transition to GroupProgress
-      def apply_group_state_transition(progress, group_name, state, duration, error)
-        case state
-        when :running
-          group = GroupProgress.new(group_name)
-          group.state = :running
-          group.start_time = Time.now
-          progress.groups << group
-          progress.current_group_index = progress.groups.size - 1
-        when :completed
-          group = progress.groups.find { |g| g.name == group_name && g.state == :running }
-          if group
-            group.state = :completed
-            group.end_time = Time.now
-            group.duration = duration
-          end
-          progress.current_group_index = nil
-        when :failed
-          group = progress.groups.find { |g| g.name == group_name && g.state == :running }
-          if group
-            group.state = :failed
-            group.end_time = Time.now
-            group.duration = duration
-            group.error = error
-          end
-          progress.current_group_index = nil
-        end
-      end
-    end
-  end
-end