taski 0.8.3 → 0.9.1

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

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../theme/detail"
+
+module Taski
+  module Progress
+    module Layout
+      # Tree layout for hierarchical task display.
+      # Renders tasks in a tree structure with visual connectors (├──, └──, │).
+      #
+      # Operates in two modes:
+      # - TTY mode: Periodic full-tree refresh with spinner animation
+      # - Non-TTY mode: Incremental output with tree prefixes (for logs/tests)
+      #
+      # Output format (live updating):
+      #   BuildApplication
+      #   ├── ⠹ SetupDatabase
+      #   │   ├── ✓ CreateSchema (50ms)
+      #   │   └── ⠹ SeedData
+      #   ├── ○ ExtractLayers
+      #   │   ├── ✓ DownloadLayer1 (100ms)
+      #   │   └── ○ DownloadLayer2
+      #   └── ✓ RunSystemCommand (200ms)
+      #
+      # The tree structure (prefixes) is added by this Layout.
+      # The task content (icons, names, duration) comes from the Theme.
+      #
+      # This demonstrates the Theme/Layout separation:
+      # - Theme defines "what one line looks like" (icons, colors, formatting)
+      # - Layout defines "how lines are arranged" (tree structure, prefixes)
+      #
+      # @example Using with Theme::Default
+      #   layout = Taski::Progress::Layout::Tree.new(theme: Taski::Progress::Theme::Default.new)
+      class Tree < Base
+        # Tree connector characters
+        BRANCH = "├── "
+        LAST_BRANCH = "└── "
+        VERTICAL = "│   "
+        SPACE = "    "
+
+        def initialize(output: $stderr, theme: nil)
+          theme ||= Theme::Detail.new
+          super
+          @tree_nodes = {}
+          @node_depths = {}
+          @node_is_last = {}
+          @renderer_thread = nil
+          @running = false
+          @running_mutex = Mutex.new
+          @last_line_count = 0
+          @non_tty_started = false
+        end
+
+        # 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
+
+        # Override on_start to handle non-TTY mode
+        def on_start
+          @monitor.synchronize do
+            @nest_level += 1
+            return if @nest_level > 1
+
+            @start_time = Time.now
+
+            if should_activate?
+              @active = true
+            else
+              # Non-TTY mode: output execution start message
+              @non_tty_started = true
+              output_line(render_execution_started(@root_task_class)) if @root_task_class
+            end
+          end
+
+          handle_start if @active
+        end
+
+        # Override on_stop to handle non-TTY mode
+        def on_stop
+          was_active = false
+          non_tty_was_started = false
+          @monitor.synchronize do
+            @nest_level -= 1 if @nest_level > 0
+            return unless @nest_level == 0
+            was_active = @active
+            non_tty_was_started = @non_tty_started
+            @active = false
+            @non_tty_started = false
+          end
+
+          if was_active
+            handle_stop
+          elsif non_tty_was_started
+            # Non-TTY mode: output execution summary
+            output_execution_summary
+          end
+          flush_queued_messages
+        end
+
+        protected
+
+        def handle_ready
+          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
+
+        # In TTY mode, tree is updated by render_live periodically.
+        # In non-TTY mode, output lines immediately with tree prefix.
+        def handle_task_update(task_class, current_state, phase)
+          return if @active  # TTY mode: skip per-event output
+
+          # Non-TTY mode: output with tree prefix
+          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)
+          return if @active  # TTY mode: skip per-event output
+
+          # Non-TTY mode: output with tree prefix
+          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)
+          return if @active  # TTY mode: skip per-event output
+
+          # Non-TTY mode: output with tree prefix
+          text = render_group_succeeded(task_class, group_name: group_name, task_duration: duration)
+          output_with_prefix(task_class, text) if text
+        end
+
+        def should_activate?
+          tty?
+        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
+        end
+
+        def handle_stop
+          @running_mutex.synchronize { @running = false }
+          @renderer_thread&.join
+          stop_spinner_timer
+          @output.print "\e[?25h" # Show cursor
+          render_final
+        end
+
+        private
+
+        # 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
+
+        # Output execution summary for non-TTY mode
+        def output_execution_summary
+          output_line(render_execution_summary)
+        end
+
+        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 render_live
+          @monitor.synchronize do
+            lines = build_tree_lines
+            clear_previous_output
+            lines.each { |line| @output.puts line }
+            @output.flush
+            @last_line_count = lines.size
+          end
+        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
+
+        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

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

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Taski
+  module Progress
+    module Theme
+      # Base class for theme definitions.
+      # Theme classes are thin layers that only return Liquid template strings.
+      # Rendering (Liquid parsing) is handled by Layout classes.
+      #
+      # Themes have access to two Drop objects:
+      #   task: Task-specific info (name, state, duration, error_message, group_name, stdout)
+      #   execution: Execution-level info (state, pending_count, done_count, completed_count,
+      #              failed_count, total_count, total_duration, root_task_name, task_names)
+      #
+      # Use {% if variable %} to conditionally render when a value is present.
+      #
+      # @example Custom theme
+      #   class MyTheme < Taski::Progress::Theme::Base
+      #     def task_start
+      #       "Starting {{ task.name }}..."
+      #     end
+      #   end
+      #
+      #   layout = Taski::Progress::Layout::Log.new(theme: MyTheme.new)
+      class Base
+        # === Task lifecycle templates ===
+
+        def task_pending
+          "[PENDING] {{ task.name | short_name }}"
+        end
+
+        def task_start
+          "[START] {{ task.name | short_name }}"
+        end
+
+        def task_success
+          "[DONE] {{ task.name | short_name }}{% if task.duration %} ({{ task.duration | format_duration }}){% endif %}"
+        end
+
+        def task_fail
+          "[FAIL] {{ task.name | short_name }}{% if task.error_message %}: {{ task.error_message }}{% endif %}"
+        end
+
+        def task_skip
+          "[SKIP] {{ task.name | short_name }}"
+        end
+
+        # === Clean lifecycle templates ===
+
+        def clean_start
+          "[CLEAN] {{ task.name | short_name }}"
+        end
+
+        def clean_success
+          "[CLEAN DONE] {{ task.name | short_name }}{% if task.duration %} ({{ task.duration | format_duration }}){% endif %}"
+        end
+
+        def clean_fail
+          "[CLEAN FAIL] {{ task.name | short_name }}{% if task.error_message %}: {{ task.error_message }}{% endif %}"
+        end
+
+        # === Group lifecycle templates ===
+
+        def group_start
+          '[GROUP] {{ task.name | short_name }}#{{ task.group_name }}'
+        end
+
+        def group_success
+          '[GROUP DONE] {{ task.name | short_name }}#{{ task.group_name }}{% if task.duration %} ({{ task.duration | format_duration }}){% endif %}'
+        end
+
+        def group_fail
+          '[GROUP FAIL] {{ task.name | short_name }}#{{ task.group_name }}{% if task.error_message %}: {{ task.error_message }}{% endif %}'
+        end
+
+        # === Execution lifecycle templates ===
+
+        def execution_start
+          "[TASKI] Starting {{ execution.root_task_name | short_name }}"
+        end
+
+        def execution_running
+          "[TASKI] Running: {{ execution.done_count }}/{{ execution.total_count }} tasks"
+        end
+
+        def execution_complete
+          "[TASKI] Completed: {{ execution.completed_count }}/{{ execution.total_count }} tasks ({{ execution.total_duration | format_duration }})"
+        end
+
+        def execution_fail
+          "[TASKI] Failed: {{ execution.failed_count }}/{{ execution.total_count }} tasks ({{ execution.total_duration | format_duration }})"
+        end
+
+        # === Spinner configuration ===
+
+        # Spinner animation frames
+        # @return [Array<String>] Array of spinner frame characters
+        def spinner_frames
+          %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏]
+        end
+
+        # Spinner frame update interval in seconds
+        # @return [Float] Interval between spinner frame updates
+        def spinner_interval
+          0.08
+        end
+
+        # Screen render interval in seconds
+        # @return [Float] Interval between screen updates
+        def render_interval
+          0.1
+        end
+
+        # === Icon configuration ===
+
+        # Icon for successful completion
+        # @return [String] Success icon
+        def icon_success
+          "✓"
+        end
+
+        # Icon for failure
+        # @return [String] Failure icon
+        def icon_failure
+          "✗"
+        end
+
+        # Icon for pending state
+        # @return [String] Pending icon
+        def icon_pending
+          "○"
+        end
+
+        # Icon for skipped state
+        # @return [String] Skipped icon
+        def icon_skip
+          "⊘"
+        end
+
+        # === Color configuration (ANSI codes) ===
+
+        # Green color ANSI escape code
+        # @return [String] ANSI code for green
+        def color_green
+          "\e[32m"
+        end
+
+        # Red color ANSI escape code
+        # @return [String] ANSI code for red
+        def color_red
+          "\e[31m"
+        end
+
+        # Yellow color ANSI escape code
+        # @return [String] ANSI code for yellow
+        def color_yellow
+          "\e[33m"
+        end
+
+        # Dim color ANSI escape code
+        # @return [String] ANSI code for dim
+        def color_dim
+          "\e[2m"
+        end
+
+        # Reset color ANSI escape code
+        # @return [String] ANSI code to reset color
+        def color_reset
+          "\e[0m"
+        end
+
+        # === Formatting methods (used by filters) ===
+
+        # Format a count value for display.
+        # Override in subclasses to customize count formatting.
+        #
+        # @param count [Integer] The count value
+        # @return [String] Formatted count
+        # @example
+        #   def format_count(count)
+        #     "#{count}件"
+        #   end
+        def format_count(count)
+          count.to_s
+        end
+
+        # Format a duration value for display.
+        # Override in subclasses to customize duration formatting.
+        #
+        # @param ms [Integer, Float] Duration in milliseconds
+        # @return [String] Formatted duration
+        # @example
+        #   def format_duration(ms)
+        #     "#{ms}ミリ秒"
+        #   end
+        def format_duration(ms)
+          if ms >= 1000
+            "#{(ms / 1000.0).round(1)}s"
+          else
+            "#{ms}ms"
+          end
+        end
+
+        # Separator for truncate_list filter.
+        # @return [String] Separator between list items
+        def truncate_list_separator
+          ", "
+        end
+
+        # Suffix for truncate_list filter when list is truncated.
+        # @return [String] Suffix to append when items are omitted
+        def truncate_list_suffix
+          "..."
+        end
+
+        # Suffix for truncate_text filter when text is truncated.
+        # @return [String] Suffix to append when text is truncated
+        def truncate_text_suffix
+          "..."
+        end
+      end
+    end
+  end
+end

data/lib/taski/progress/theme/compact.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "default"
+
+module Taski
+  module Progress
+    module Theme
+      # Compact theme for TTY environments with single-line progress display.
+      # Provides spinner animation, colored icons, and status formatting.
+      #
+      # Output format:
+      #   ⠹ [3/5] DeployTask | Uploading files...
+      #   ✓ [5/5] All tasks completed (1.2s)
+      #
+      # @example Usage
+      #   layout = Taski::Progress::Layout::Simple.new(
+      #     theme: Taski::Progress::Theme::Compact.new
+      #   )
+      #
+      # @example Custom spinner frames
+      #   class MoonTheme < Taski::Progress::Theme::Compact
+      #     def spinner_frames
+      #       %w[🌑 🌒 🌓 🌔 🌕 🌖 🌗 🌘]
+      #     end
+      #   end
+      #
+      # @example Custom status theme
+      #   class JapaneseTheme < Taski::Progress::Theme::Compact
+      #     def format_count(count)
+      #       "#{count}件"
+      #     end
+      #
+      #     def status_complete
+      #       '{% icon %} {{ execution.done_count | format_count }}完了 ({{ execution.total_duration | format_duration }})'
+      #     end
+      #   end
+      class Compact < Default
+        # Inherits ANSI colors from Base via Default.
+        # Adds spinner and icons for TTY environments.
+
+        # Execution running with spinner
+        def execution_running
+          "{% spinner %} [{{ execution.done_count }}/{{ execution.total_count }}]{% if execution.task_names %} {% for name in execution.task_names limit: 3 %}{{ name | short_name }}{% unless forloop.last %}, {% endunless %}{% endfor %}{% if execution.task_names.size > 3 %}...{% endif %}{% endif %}{% if task.stdout %} | {{ task.stdout | truncate_text: 40 }}{% endif %}"
+        end
+
+        # Execution complete with icon
+        def execution_complete
+          "{% icon %} [TASKI] Completed: {{ execution.completed_count }}/{{ execution.total_count }} tasks ({{ execution.total_duration | format_duration }})"
+        end
+
+        # Execution fail with icon
+        def execution_fail
+          "{% icon %} [TASKI] Failed: {{ execution.failed_count }}/{{ execution.total_count }} tasks ({{ execution.total_duration | format_duration }})"
+        end
+      end
+    end
+  end
+end

data/lib/taski/progress/theme/default.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Taski
+  module Progress
+    module Theme
+      # Default theme inheriting from Theme::Base.
+      #
+      # Note: Theme::Base provides ANSI color helper methods (color_red,
+      # color_green, etc.) which return escape codes by default. If Liquid
+      # templates or filters use these methods, output may contain escape codes.
+      #
+      # For guaranteed plain text output without any terminal escape codes,
+      # use Theme::Plain instead, which overrides all color methods to
+      # return empty strings.
+      #
+      # @see Taski::Progress::Theme::Base Base class with color helpers
+      # @see Taski::Progress::Theme::Plain Plain output without escape codes
+      class Default < Base
+        # Inherits all methods from Base.
+      end
+    end
+  end
+end

data/lib/taski/progress/theme/detail.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "default"
+
+module Taski
+  module Progress
+    module Theme
+      # Detail theme for rich progress display with spinner and icons.
+      # Provides spinner animation, colored icons for task states.
+      #
+      # Output format:
+      #   ├── ⠹ DeployTask
+      #   │   └── ✓ UploadFiles (1.2s)
+      #   └── ✗ MigrateDB: Connection refused
+      #
+      # @example Usage
+      #   layout = Taski::Progress::Layout::Tree.new(
+      #     theme: Taski::Progress::Theme::Detail.new
+      #   )
+      class Detail < Default
+        # Task pending with icon
+        def task_pending
+          "{% icon %} {{ task.name | short_name }}"
+        end
+
+        # Task start with spinner
+        def task_start
+          "{% spinner %} {{ task.name | short_name }}"
+        end
+
+        # Task success with colored icon
+        def task_success
+          "{% icon %} {{ task.name | short_name }}{% if task.duration %} ({{ task.duration | format_duration }}){% endif %}"
+        end
+
+        # Task fail with colored icon
+        def task_fail
+          "{% icon %} {{ task.name | short_name }}{% if task.error_message %}: {{ task.error_message }}{% endif %}"
+        end
+
+        # Task skip with colored icon
+        def task_skip
+          "{% icon %} {{ task.name | short_name }}"
+        end
+      end
+    end
+  end
+end

data/lib/taski/progress/theme/plain.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "default"
+
+module Taski
+  module Progress
+    module Theme
+      # Plain theme for non-TTY environments (CI, log files, piped output).
+      # Outputs plain text without terminal escape codes or colors.
+      #
+      # @example Usage
+      #   layout = Taski::Progress::Layout::Log.new(
+      #     theme: Taski::Progress::Theme::Plain.new
+      #   )
+      class Plain < Default
+        # === Color configuration (disabled for plain output) ===
+
+        def color_green
+          ""
+        end
+
+        def color_red
+          ""
+        end
+
+        def color_yellow
+          ""
+        end
+
+        def color_dim
+          ""
+        end
+
+        def color_reset
+          ""
+        end
+      end
+    end
+  end
+end