taski 0.9.0 → 0.9.2

data/lib/taski/progress/layout/base.rb

@@ -267,7 +267,7 @@ module Taski
           if failed_count > 0
             render_execution_failed(failed_count: failed_count, total_count: total_count, total_duration: total_duration, skipped_count: skipped_count)
           else
-            render_execution_completed(completed_count: completed_count, total_count: total_count, total_duration: total_duration, skipped_count: skipped_count)
+            render_execution_completed(done_count: done_count, total_count: total_count, total_duration: total_duration, skipped_count: skipped_count)
           end
         end
 
@@ -372,8 +372,8 @@ module Taski
         end
 
         # Render execution complete event
-        def render_execution_completed(completed_count:, total_count:, total_duration:, skipped_count: 0)
-          execution = ExecutionDrop.new(state: :completed, completed_count:, total_count:, total_duration:, skipped_count:)
+        def render_execution_completed(done_count:, total_count:, total_duration:, skipped_count: 0)
+          execution = ExecutionDrop.new(state: :completed, done_count:, total_count:, total_duration:, skipped_count:)
           render_execution_template(:execution_complete, execution:)
         end
 
@@ -515,6 +515,28 @@ module Taski
           task_class.name || task_class.to_s
         end
 
+        # Start a periodic render loop in a background thread.
+        # Starts spinner timer and calls the given block at @theme.render_interval.
+        # @yield Block to execute each render cycle (called under @monitor.synchronize)
+        def render_loop(&block)
+          @render_thread_running = true
+          start_spinner_timer
+          @render_thread = Thread.new do
+            while @render_thread_running
+              @monitor.synchronize(&block)
+              sleep @theme.render_interval
+            end
+          end
+        end
+
+        # Stop the periodic render loop and spinner timer.
+        def stop_render_loop
+          @render_thread_running = false
+          @render_thread&.join
+          @render_thread = nil
+          stop_spinner_timer
+        end
+
         # Check if output is a TTY
         def tty?
           @output.tty?

data/lib/taski/progress/layout/simple.rb

@@ -36,9 +36,6 @@ module Taski
         def initialize(output: $stdout, theme: nil)
           theme ||= Theme::Compact.new
           super
-          @renderer_thread = nil
-          @running = false
-          @running_mutex = Mutex.new
         end
 
         protected
@@ -70,38 +67,26 @@ module Taski
         end
 
         def handle_start
-          @running_mutex.synchronize { @running = true }
-          start_spinner_timer
           @output.print "\e[?25l"  # Hide cursor
-          @renderer_thread = Thread.new do
-            loop do
-              break unless @running_mutex.synchronize { @running }
-              render_live
-              sleep @theme.render_interval
-            end
-          end
+          render_loop { render_status_line }
         end
 
         def handle_stop
-          @running_mutex.synchronize { @running = false }
-          @renderer_thread&.join
-          stop_spinner_timer
+          stop_render_loop
           @output.print "\e[?25h"  # Show cursor
           render_final
         end
 
         private
 
-        def render_live
-          @monitor.synchronize do
-            line = build_status_line
-            # Truncate line to terminal width to prevent line wrap
-            max_width = terminal_width - 1  # Leave space for cursor
-            line = line[0, max_width] if line.length > max_width
-            # Clear line and write new content
-            @output.print "\r\e[K#{line}"
-            @output.flush
-          end
+        def render_status_line
+          line = build_status_line
+          # Truncate line to terminal width to prevent line wrap
+          max_width = terminal_width - 1  # Leave space for cursor
+          line = line[0, max_width] if line.length > max_width
+          # Clear line and write new content
+          @output.print "\r\e[K#{line}"
+          @output.flush
         end
 
         def terminal_width
@@ -113,9 +98,9 @@ module Taski
         def render_final
           @monitor.synchronize do
             line = if failed_count > 0
-              render_execution_failed(failed_count: failed_count, total_count: total_count, total_duration: total_duration)
+              render_execution_failed(failed_count: failed_count, total_count: total_count, total_duration: total_duration, skipped_count: skipped_count)
             else
-              render_execution_completed(completed_count: completed_count, total_count: total_count, total_duration: total_duration)
+              render_execution_completed(done_count: done_count, total_count: total_count, total_duration: total_duration, skipped_count: skipped_count)
             end
 
             @output.print "\r\e[K#{line}\n"
@@ -126,7 +111,7 @@ module Taski
         def build_status_line
           task_names = collect_current_task_names
 
-          primary_task = running_tasks.keys.first || cleaning_tasks.keys.first
+          primary_task = running_tasks.keys.last || cleaning_tasks.keys.last
           task_stdout = build_task_stdout(primary_task)
 
           render_execution_running(
@@ -139,12 +124,13 @@ module Taski
 
         def collect_current_task_names
           # Prioritize: cleaning > running > pending
+          # Reverse so most recently started tasks appear first
           current_tasks = if cleaning_tasks.any?
-            cleaning_tasks.keys
+            cleaning_tasks.keys.reverse
           elsif running_tasks.any?
-            running_tasks.keys
+            running_tasks.keys.reverse
           elsif pending_tasks.any?
-            pending_tasks.keys
+            pending_tasks.keys.reverse
           else
             []
           end

data/lib/taski/progress/layout/theme_drop.rb

@@ -76,7 +76,7 @@ module Taski
       #   failed_count, total_count, total_duration, root_task_name, task_names
       #
       # @example Using in Liquid template
-      #   [{{ execution.completed_count }}/{{ execution.total_count }}]
+      #   [{{ execution.done_count }}/{{ execution.total_count }}]
       #   {{ execution.total_duration | format_duration }}
       class ExecutionDrop < DataDrop; end
     end

data/lib/taski/progress/layout/tree/event.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+require_relative "../../theme/detail"
+require_relative "structure"
+
+module Taski
+  module Progress
+    module Layout
+      module Tree
+        # Non-TTY event-driven tree layout.
+        # Outputs lines immediately with tree prefixes as events arrive.
+        # Used for logs, CI, piped output, and static tree display.
+        class Event < Base
+          include Structure
+
+          def initialize(output: $stderr, theme: nil)
+            theme ||= Theme::Detail.new
+            super
+            init_tree_structure
+          end
+
+          protected
+
+          def handle_ready
+            build_ready_tree
+          end
+
+          def handle_task_update(task_class, current_state, phase)
+            progress = @tasks[task_class]
+            duration = compute_duration(progress, phase)
+            text = render_for_task_event(task_class, current_state, duration, nil, phase)
+            output_with_prefix(task_class, text) if text
+          end
+
+          def handle_group_started(task_class, group_name, phase)
+            text = render_group_started(task_class, group_name: group_name)
+            output_with_prefix(task_class, text) if text
+          end
+
+          def handle_group_completed(task_class, group_name, phase, duration)
+            text = render_group_succeeded(task_class, group_name: group_name, task_duration: duration)
+            output_with_prefix(task_class, text) if text
+          end
+        end
+      end
+    end
+  end
+end

data/lib/taski/progress/layout/tree/live.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+require_relative "../../theme/detail"
+require_relative "structure"
+
+module Taski
+  module Progress
+    module Layout
+      module Tree
+        # TTY periodic-update tree layout.
+        # Refreshes the entire tree display at regular intervals with spinner animation.
+        # Used for interactive terminal output.
+        class Live < Base
+          include Structure
+
+          def initialize(output: $stderr, theme: nil)
+            theme ||= Theme::Detail.new
+            super
+            init_tree_structure
+            @last_line_count = 0
+          end
+
+          protected
+
+          def handle_ready
+            build_ready_tree
+          end
+
+          # TTY mode: skip per-event output, tree is updated by render_loop
+          def handle_task_update(_task_class, _current_state, _phase)
+          end
+
+          def handle_group_started(_task_class, _group_name, _phase)
+          end
+
+          def handle_group_completed(_task_class, _group_name, _phase, _duration)
+          end
+
+          def should_activate?
+            tty?
+          end
+
+          def handle_start
+            @output.print "\e[?25l" # Hide cursor
+            render_loop { render_tree_live }
+          end
+
+          def handle_stop
+            stop_render_loop
+            @output.print "\e[?25h" # Show cursor
+            render_final
+          end
+
+          private
+
+          def render_tree_live
+            lines = build_tree_lines
+            clear_previous_output
+            lines.each { |line| @output.puts line }
+            @output.flush
+            @last_line_count = lines.size
+          end
+
+          def render_final
+            @monitor.synchronize do
+              lines = build_tree_lines
+              clear_previous_output
+
+              lines.each { |line| @output.puts line }
+              @output.puts render_execution_summary
+              @output.flush
+            end
+          end
+
+          def clear_previous_output
+            return if @last_line_count == 0
+            # Move cursor up and clear lines
+            @output.print "\e[#{@last_line_count}A\e[J"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/taski/progress/layout/tree/structure.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Taski
+  module Progress
+    module Layout
+      module Tree
+        # Shared tree structure logic for Tree::Live and Tree::Event.
+        # Provides tree building, node registration, prefix generation,
+        # and tree rendering methods.
+        module Structure
+          # Tree connector characters
+          BRANCH = "├── "
+          LAST_BRANCH = "└── "
+          VERTICAL = "│   "
+          SPACE = "    "
+
+          # Returns the tree structure as a string.
+          # Uses the current theme to render task content for each node.
+          def render_tree
+            build_tree_lines.join("\n") + "\n"
+          end
+
+          protected
+
+          def init_tree_structure
+            @tree_nodes = {}
+            @node_depths = {}
+            @node_is_last = {}
+          end
+
+          def build_ready_tree
+            graph = context&.dependency_graph
+            root = context&.root_task_class
+            return unless graph && root
+
+            tree = build_tree_from_graph(root, graph)
+            register_tree_nodes(tree, depth: 0, is_last: true, ancestors_last: [])
+          end
+
+          # Output text with tree prefix for the given task
+          def output_with_prefix(task_class, text)
+            prefix = build_tree_prefix(task_class)
+            output_line("#{prefix}#{text}")
+          end
+
+          private
+
+          def build_tree_from_graph(task_class, graph, ancestors = Set.new)
+            is_circular = ancestors.include?(task_class)
+            node = {task_class: task_class, is_circular: is_circular, children: []}
+            return node if is_circular
+
+            new_ancestors = ancestors + [task_class]
+            deps = graph.dependencies_for(task_class)
+            deps.each do |dep|
+              child_node = build_tree_from_graph(dep, graph, new_ancestors)
+              node[:children] << child_node
+            end
+            node
+          end
+
+          def register_tree_nodes(node, depth:, is_last:, ancestors_last:)
+            return unless node
+
+            task_class = node[:task_class]
+            @tasks[task_class] ||= new_task_progress
+            @tree_nodes[task_class] = node
+            @node_depths[task_class] = depth
+            @node_is_last[task_class] = {is_last: is_last, ancestors_last: ancestors_last.dup}
+
+            children = node[:children]
+            children.each_with_index do |child, index|
+              child_is_last = (index == children.size - 1)
+              new_ancestors_last = ancestors_last + [is_last]
+              register_tree_nodes(child, depth: depth + 1, is_last: child_is_last, ancestors_last: new_ancestors_last)
+            end
+          end
+
+          def build_tree_lines
+            return [] unless @root_task_class
+
+            lines = []
+            root_node = @tree_nodes[@root_task_class]
+            build_node_lines(root_node, lines)
+            lines
+          end
+
+          def build_node_lines(node, lines)
+            return unless node
+
+            task_class = node[:task_class]
+            prefix = build_tree_prefix(task_class)
+            content = build_task_content(task_class)
+            lines << "#{prefix}#{content}"
+
+            node[:children].each do |child|
+              build_node_lines(child, lines)
+            end
+          end
+
+          def build_task_content(task_class)
+            progress = @tasks[task_class]
+
+            case progress&.dig(:run_state)
+            when :running
+              render_task_started(task_class)
+            when :completed
+              render_task_succeeded(task_class, task_duration: compute_duration(progress, :run))
+            when :failed
+              render_task_failed(task_class, error: nil)
+            when :skipped
+              render_task_skipped(task_class)
+            else
+              task = TaskDrop.new(name: task_class_name(task_class), state: :pending)
+              render_task_template(:task_pending, task:, execution: execution_drop)
+            end
+          end
+
+          def build_tree_prefix(task_class)
+            depth = @node_depths[task_class]
+            return "" if depth.nil? || depth == 0
+
+            last_info = @node_is_last[task_class]
+            return "" unless last_info
+
+            ancestors_last = last_info[:ancestors_last]
+            is_last = last_info[:is_last]
+
+            prefix = ""
+            # Skip the first ancestor (root) since root has no visual prefix
+            ancestors_last[1..].each do |ancestor_is_last|
+              prefix += ancestor_is_last ? SPACE : VERTICAL
+            end
+
+            prefix += is_last ? LAST_BRANCH : BRANCH
+            prefix
+          end
+        end
+      end
+    end
+  end
+end