taski 0.8.3 → 0.9.1

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Taski
+  module Progress
+    module Layout
+      # Liquid filter module for colorizing text output.
+      # Uses ThemeDrop from context to get color codes, falls back to defaults.
+      #
+      # @example Usage in Liquid template
+      #   {{ task.name | green }}
+      #   {{ task.error_message | red }}
+      #   {{ task.state | dim }}
+      module ColorFilter
+        DEFAULT_COLORS = {
+          red: "\e[31m",
+          green: "\e[32m",
+          yellow: "\e[33m",
+          dim: "\e[2m",
+          reset: "\e[0m"
+        }.freeze
+
+        def red(input) = colorize(input, :red)
+        def green(input) = colorize(input, :green)
+        def yellow(input) = colorize(input, :yellow)
+        def dim(input) = colorize(input, :dim)
+
+        # Format a count value using Theme's format_count method.
+        # Falls back to to_s if no template is provided.
+        #
+        # @example
+        #   {{ execution.done_count | format_count }}
+        def format_count(input)
+          template = @context["template"]
+          template&.format_count(input) || input.to_s
+        end
+
+        # Format a duration value using Theme's format_duration method.
+        # Falls back to default formatting if no template is provided.
+        #
+        # @example
+        #   {{ task.duration | format_duration }}
+        #   {{ execution.total_duration | format_duration }}
+        def format_duration(input)
+          return "" if input.nil?
+
+          template = @context["template"]
+          template&.format_duration(input) || default_format_duration(input)
+        end
+
+        # Truncate a list to a maximum number of items, joining with separator.
+        # Uses Theme's truncate_list_separator and truncate_list_suffix if available.
+        #
+        # @example
+        #   {{ execution.task_names | truncate_list: 3 }}
+        #   # => "TaskA, TaskB, TaskC..."
+        def truncate_list(input, limit = 3)
+          return "" if input.nil?
+
+          items = input.is_a?(Array) ? input : [input]
+          return "" if items.empty?
+
+          template = @context["template"]
+          separator = template&.truncate_list_separator || ", "
+          suffix = template&.truncate_list_suffix || "..."
+
+          truncated = items.first(limit)
+          result = truncated.join(separator)
+          result += suffix if items.size > limit
+          result
+        end
+
+        # Extract short name from a fully qualified class name.
+        # Returns the last component after "::".
+        #
+        # @example
+        #   {{ task.name | short_name }}
+        #   # "MyModule::MyTask" => "MyTask"
+        def short_name(input)
+          return "" if input.nil?
+          input.to_s.split("::").last || input.to_s
+        end
+
+        # Truncate text to a maximum length, adding suffix if truncated.
+        # Uses Theme's truncate_text_suffix if available.
+        #
+        # @example
+        #   {{ task.stdout | truncate_text: 40 }}
+        #   # => "Uploading files to server..."
+        def truncate_text(input, max_length = 40)
+          return "" if input.nil?
+          return "" if max_length <= 0
+
+          text = input.to_s
+          return text if text.length <= max_length
+
+          template = @context["template"]
+          suffix = template&.truncate_text_suffix || "..."
+
+          truncated_length = [max_length - suffix.length, 0].max
+          if truncated_length == 0
+            suffix[0, max_length]
+          else
+            text[0, truncated_length] + suffix
+          end
+        end
+
+        private
+
+        def colorize(input, color_name)
+          template = @context["template"]
+          color = template&.public_send(:"color_#{color_name}") || DEFAULT_COLORS[color_name]
+          reset = template&.color_reset || DEFAULT_COLORS[:reset]
+          "#{color}#{input}#{reset}"
+        end
+
+        def default_format_duration(ms)
+          if ms >= 1000
+            "#{(ms / 1000.0).round(1)}s"
+          else
+            "#{ms}ms"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../theme/plain"
+
+module Taski
+  module Progress
+    module Layout
+      # Log layout for non-TTY environments (CI, log files, piped output).
+      # Outputs plain text without terminal escape codes.
+      #
+      # Output format:
+      #   [START] TaskName
+      #   [DONE] TaskName (123.4ms)
+      #   [FAIL] TaskName: Error message
+      #
+      # Uses Theme::Plain by default to ensure no ANSI escape codes in output.
+      class Log < Base
+        def initialize(output: $stderr, theme: nil)
+          theme ||= Theme::Plain.new
+          super
+          @output.sync = true if @output.respond_to?(:sync=)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../theme/compact"
+
+module Taski
+  module Progress
+    module Layout
+      # Simple layout providing a minimalist single-line progress display.
+      # Shows task execution status in a compact format with spinner animation:
+      #
+      #   ⠹ [3/5] DeployTask | Uploading files...
+      #
+      # Customization is done through Theme classes:
+      #
+      #   class MyTheme < Taski::Progress::Theme::Base
+      #     def spinner_frames
+      #       %w[🌑 🌒 🌓 🌔 🌕 🌖 🌗 🌘]
+      #     end
+      #
+      #     def icon_success
+      #       "🎉"
+      #     end
+      #
+      #     def format_count(count)
+      #       "#{count}件"
+      #     end
+      #
+      #     def execution_complete
+      #       '{% icon %} Done! {{ execution.completed_count | format_count }} tasks in {{ execution.total_duration | format_duration }}'
+      #     end
+      #   end
+      #
+      #   layout = Taski::Progress::Layout::Simple.new(theme: MyTheme.new)
+      class Simple < Base
+        def initialize(output: $stdout, theme: nil)
+          theme ||= Theme::Compact.new
+          super
+          @renderer_thread = nil
+          @running = false
+          @running_mutex = Mutex.new
+        end
+
+        protected
+
+        # === Template method overrides ===
+
+        def handle_ready
+          graph = context&.dependency_graph
+          return unless graph
+
+          graph.all_tasks.each { |tc| register_task(tc) }
+        end
+
+        # Simple layout uses periodic status line updates instead of per-event output
+        def handle_task_update(_task_class, _current_state, _phase)
+          # No per-event output; status line is updated by render_live
+        end
+
+        def handle_group_started(_task_class, _group_name, _phase)
+          # No per-event output; status line is updated by render_live
+        end
+
+        def handle_group_completed(_task_class, _group_name, _phase, _duration)
+          # No per-event output; status line is updated by render_live
+        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
+
+        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
+        end
+
+        def terminal_width
+          @output.winsize[1]
+        rescue
+          80 # Default fallback
+        end
+
+        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)
+            else
+              render_execution_completed(completed_count: completed_count, total_count: total_count, total_duration: total_duration)
+            end
+
+            @output.print "\r\e[K#{line}\n"
+            @output.flush
+          end
+        end
+
+        def build_status_line
+          task_names = collect_current_task_names
+
+          primary_task = running_tasks.keys.first || cleaning_tasks.keys.first
+          task_stdout = build_task_stdout(primary_task)
+
+          render_execution_running(
+            done_count: done_count,
+            total_count: total_count,
+            task_names: task_names.empty? ? nil : task_names,
+            task_stdout: task_stdout
+          )
+        end
+
+        def collect_current_task_names
+          # Prioritize: cleaning > running > pending
+          current_tasks = if cleaning_tasks.any?
+            cleaning_tasks.keys
+          elsif running_tasks.any?
+            running_tasks.keys
+          elsif pending_tasks.any?
+            pending_tasks.keys
+          else
+            []
+          end
+
+          current_tasks.map { |t| task_class_name(t) }
+        end
+
+        def build_task_stdout(task_class)
+          return nil unless @output_capture && task_class
+
+          last_line = @output_capture.last_line_for(task_class)
+          return nil unless last_line && !last_line.strip.empty?
+
+          last_line.strip
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "liquid"
+require_relative "filters"
+
+module Taski
+  module Progress
+    module Layout
+      # Liquid tag for rendering animated spinner characters.
+      # Uses ThemeDrop from context to get spinner frames, falls back to defaults.
+      # Uses spinner_index from context to determine current frame.
+      #
+      # @example Usage in Liquid template
+      #   {% spinner %} Loading...
+      #   {% spinner %} [{{ done }}/{{ total }}]
+      class SpinnerTag < Liquid::Tag
+        DEFAULT_FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
+
+        def render(context)
+          template = context["template"]
+          frames = template&.spinner_frames || DEFAULT_FRAMES
+          index = context["spinner_index"] || 0
+          frames[index % frames.size]
+        end
+      end
+
+      # Liquid tag for rendering status icons based on current state.
+      # Uses ThemeDrop from context to get icons and colors.
+      # Uses state from context to determine which icon to show.
+      #
+      # @example Usage in Liquid template
+      #   {% icon %} Task completed
+      #   {% icon %} [{{ done }}/{{ total }}]
+      class IconTag < Liquid::Tag
+        DEFAULTS = {
+          icon_success: "✓",
+          icon_failure: "✗",
+          icon_pending: "○",
+          icon_skip: "⊘",
+          color_green: ColorFilter::DEFAULT_COLORS[:green],
+          color_red: ColorFilter::DEFAULT_COLORS[:red],
+          color_yellow: ColorFilter::DEFAULT_COLORS[:yellow],
+          color_dim: ColorFilter::DEFAULT_COLORS[:dim],
+          color_reset: ColorFilter::DEFAULT_COLORS[:reset]
+        }.freeze
+
+        STATE_CONFIG = {
+          "completed" => {icon: :icon_success, color: :color_green},
+          "failed" => {icon: :icon_failure, color: :color_red},
+          "running" => {icon: :icon_pending, color: :color_yellow},
+          "skipped" => {icon: :icon_skip, color: :color_dim}
+        }.freeze
+
+        def render(context)
+          @template = context["template"]
+          state = context["state"]&.to_s
+
+          config = STATE_CONFIG[state]
+          return get_value(:icon_pending) unless config
+
+          colorize(get_value(config[:icon]), config[:color])
+        end
+
+        private
+
+        def get_value(key)
+          @template&.public_send(key) || DEFAULTS[key]
+        end
+
+        def colorize(icon, color_key)
+          "#{get_value(color_key)}#{icon}#{get_value(:color_reset)}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "liquid"
+
+module Taski
+  module Progress
+    module Layout
+      # Liquid Drop for Theme to enable method access from filters/tags.
+      # Wraps a Theme instance and delegates color/icon/spinner methods.
+      #
+      # @example Using in Liquid context
+      #   drop = ThemeDrop.new(theme)
+      #   Liquid::Template.parse("{{ theme.color_red }}")
+      #                   .render("theme" => drop)
+      class ThemeDrop < Liquid::Drop
+        def initialize(theme)
+          @theme = theme
+        end
+
+        # Color methods
+        def color_red = @theme.color_red
+        def color_green = @theme.color_green
+        def color_yellow = @theme.color_yellow
+        def color_dim = @theme.color_dim
+        def color_reset = @theme.color_reset
+
+        # Spinner settings
+        def spinner_frames = @theme.spinner_frames
+        def spinner_interval = @theme.spinner_interval
+        def render_interval = @theme.render_interval
+
+        # Status icons
+        def icon_success = @theme.icon_success
+        def icon_failure = @theme.icon_failure
+        def icon_pending = @theme.icon_pending
+        def icon_skip = @theme.icon_skip
+
+        # Formatting methods (used by filters)
+        def format_count(count) = @theme.format_count(count)
+        def format_duration(ms) = @theme.format_duration(ms)
+
+        # List truncation settings
+        def truncate_list_separator = @theme.truncate_list_separator
+        def truncate_list_suffix = @theme.truncate_list_suffix
+
+        # Text truncation settings
+        def truncate_text_suffix = @theme.truncate_text_suffix
+      end
+
+      # Base class for Liquid Drops with dynamic property access.
+      # Provides common functionality for TaskDrop and ExecutionDrop.
+      class DataDrop < Liquid::Drop
+        def initialize(**data)
+          @data = data
+        end
+
+        def liquid_method_missing(method)
+          @data[method.to_sym]
+        end
+      end
+
+      # Liquid Drop for task-specific variables.
+      # Provides access to individual task information in templates.
+      #
+      # Available properties: name, state, duration, error_message, group_name, stdout
+      #
+      # @example Using in Liquid template
+      #   {{ task.name }} ({{ task.state }})
+      #   {{ task.duration | format_duration }}
+      class TaskDrop < DataDrop; end
+
+      # Liquid Drop for execution-level variables.
+      # Provides access to overall execution state in templates.
+      #
+      # Available properties: state, pending_count, done_count, completed_count,
+      #   failed_count, total_count, total_duration, root_task_name, task_names
+      #
+      # @example Using in Liquid template
+      #   [{{ execution.completed_count }}/{{ execution.total_count }}]
+      #   {{ execution.total_duration | format_duration }}
+      class ExecutionDrop < DataDrop; end
+    end
+  end
+end