taski 0.2.2 → 0.3.0

data/lib/taski/dependency_analyzer.rb

@@ -15,52 +15,79 @@ module Taski
         file_path, line_number = source_location
         return [] unless File.exist?(file_path)
 
-        begin
-          result = Prism.parse_file(file_path)
-
-          unless result.success?
-            Taski.logger.error("Parse errors in source file",
-              file: file_path,
-              errors: result.errors.map(&:message),
-              method: "#{klass}##{method_name}")
-            return []
-          end
+        parse_source_file(file_path, line_number, klass, method_name)
+      end
 
-          # Handle warnings if present
-          if result.warnings.any?
-            Taski.logger.warn("Parse warnings in source file",
-              file: file_path,
-              warnings: result.warnings.map(&:message),
-              method: "#{klass}##{method_name}")
-          end
+      private
 
-          dependencies = []
-          method_node = find_method_node(result.value, method_name, line_number)
+      # Parse source file and extract dependencies with proper error handling
+      # @param file_path [String] Path to source file
+      # @param line_number [Integer] Line number of method definition
+      # @param klass [Class] Class containing the method
+      # @param method_name [Symbol] Method name being analyzed
+      # @return [Array<Class>] Array of dependency classes
+      def parse_source_file(file_path, line_number, klass, method_name)
+        result = Prism.parse_file(file_path)
+        handle_parse_errors(result, file_path, klass, method_name)
+        extract_dependencies_from_node(result.value, line_number, klass, method_name)
+      rescue IOError, SystemCallError => e
+        Taski.logger.error("Failed to read source file",
+          file: file_path,
+          error: e.message,
+          method: "#{klass}##{method_name}")
+        []
+      rescue => e
+        Taski.logger.error("Failed to analyze method dependencies",
+          class: klass.name,
+          method: method_name,
+          error: e.message,
+          error_class: e.class.name)
+        []
+      end
 
-          if method_node
-            visitor = TaskDependencyVisitor.new
-            visitor.visit(method_node)
-            dependencies = visitor.dependencies
-          end
+      # Handle parse errors and warnings from Prism parsing
+      # @param result [Prism::ParseResult] Parse result from Prism
+      # @param file_path [String] Path to source file
+      # @param klass [Class] Class containing the method
+      # @param method_name [Symbol] Method name being analyzed
+      # @return [Array] Empty array if errors found
+      # @raise [RuntimeError] If parse fails
+      def handle_parse_errors(result, file_path, klass, method_name)
+        unless result.success?
+          Taski.logger.error("Parse errors in source file",
+            file: file_path,
+            errors: result.errors.map(&:message),
+            method: "#{klass}##{method_name}")
+          return []
+        end
 
-          dependencies.uniq
-        rescue IOError, SystemCallError => e
-          Taski.logger.error("Failed to read source file",
+        # Handle warnings if present
+        if result.warnings.any?
+          Taski.logger.warn("Parse warnings in source file",
             file: file_path,
-            error: e.message,
+            warnings: result.warnings.map(&:message),
             method: "#{klass}##{method_name}")
-          []
-        rescue => e
-          Taski.logger.error("Failed to analyze method dependencies",
-            class: klass.name,
-            method: method_name,
-            error: e.message,
-            error_class: e.class.name)
-          []
         end
       end
 
-      private
+      # Extract dependencies from parsed AST node
+      # @param root_node [Prism::Node] Root AST node
+      # @param line_number [Integer] Line number of method definition
+      # @param klass [Class] Class containing the method
+      # @param method_name [Symbol] Method name being analyzed
+      # @return [Array<Class>] Array of unique dependency classes
+      def extract_dependencies_from_node(root_node, line_number, klass, method_name)
+        dependencies = []
+        method_node = find_method_node(root_node, method_name, line_number)
+
+        if method_node
+          visitor = TaskDependencyVisitor.new(klass)
+          visitor.visit(method_node)
+          dependencies = visitor.dependencies
+        end
+
+        dependencies.uniq
+      end
 
       def find_method_node(node, method_name, target_line)
         return nil unless node
@@ -96,9 +123,10 @@ module Taski
       class TaskDependencyVisitor < Prism::Visitor
         attr_reader :dependencies
 
-        def initialize
+        def initialize(context_class = nil)
           @dependencies = []
           @constant_cache = {}
+          @context_class = context_class
         end
 
         def visit_constant_read_node(node)
@@ -135,14 +163,19 @@ module Taski
           return @dependencies << cached_result if cached_result # Cached positive result
 
           begin
+            resolved_class = nil
+
+            # 1. Try absolute reference first (existing logic)
             if Object.const_defined?(const_name)
-              klass = Object.const_get(const_name)
-              if klass.is_a?(Class) && klass < Taski::Task
-                @constant_cache[const_name] = klass
-                @dependencies << klass
-              else
-                @constant_cache[const_name] = false
-              end
+              resolved_class = Object.const_get(const_name)
+            # 2. Try relative reference within namespace context
+            elsif @context_class
+              resolved_class = resolve_relative_constant(const_name)
+            end
+
+            if resolved_class&.is_a?(Class) && (resolved_class < Taski::Task || resolved_class < Taski::Section)
+              @constant_cache[const_name] = resolved_class
+              @dependencies << resolved_class
             else
               @constant_cache[const_name] = false
             end
@@ -151,6 +184,32 @@ module Taski
           end
         end
 
+        def resolve_relative_constant(const_name)
+          return nil unless @context_class
+
+          # Get the namespace from the context class
+          namespace = get_namespace_from_class(@context_class)
+          return nil unless namespace
+
+          # Try to resolve the constant within the namespace
+          full_const_name = "#{namespace}::#{const_name}"
+          Object.const_get(full_const_name) if Object.const_defined?(full_const_name)
+        rescue NameError, ArgumentError
+          nil
+        end
+
+        def get_namespace_from_class(klass)
+          # Extract namespace from class name (e.g., "A::AB" -> "A")
+          class_name = klass.name
+          return nil unless class_name&.include?("::")
+
+          # Split by "::" and take all but the last part
+          parts = class_name.split("::")
+          return nil if parts.length <= 1  # No namespace
+
+          parts[0..-2].join("::")
+        end
+
         def extract_constant_path(node)
           case node
           when Prism::ConstantReadNode

data/lib/taski/exceptions.rb

@@ -11,4 +11,7 @@ module Taski
 
   # Raised when task building fails during execution
   class TaskBuildError < StandardError; end
+
+  # Raised when section implementation method is missing
+  class SectionImplementationError < StandardError; end
 end

data/lib/taski/logger.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "logging/formatter_factory"
+
 module Taski
   # Enhanced logging functionality for Taski framework
   # Provides structured logging with multiple levels and context information
@@ -13,7 +15,7 @@ module Taski
     def initialize(level: :info, output: $stdout, format: :structured)
       @level = level
       @output = output
-      @format = format
+      @formatter = Logging::FormatterFactory.create(format)
       @start_time = Time.now
     end
 
@@ -103,21 +105,15 @@ module Taski
 
     private
 
-    # Core logging method
+    # Core logging method using Strategy Pattern
     # @param level [Symbol] Log level
     # @param message [String] Log message
     # @param context [Hash] Additional context
     def log(level, message, context)
       return unless should_log?(level)
 
-      case @format
-      when :simple
-        log_simple(level, message, context)
-      when :structured
-        log_structured(level, message, context)
-      when :json
-        log_json(level, message, context)
-      end
+      formatted_line = @formatter.format(level, message, context, @start_time)
+      @output.puts formatted_line
     end
 
     # Check if message should be logged based on current level
@@ -126,57 +122,6 @@ module Taski
     def should_log?(level)
       LEVELS[@level] <= LEVELS[level]
     end
-
-    # Simple log format: [LEVEL] message
-    def log_simple(level, message, context)
-      @output.puts "[#{level.upcase}] #{message}"
-    end
-
-    # Structured log format with timestamp and context
-    def log_structured(level, message, context)
-      timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S.%3N")
-      elapsed = ((Time.now - @start_time) * 1000).round(1)
-
-      line = "[#{timestamp}] [#{elapsed}ms] #{level.to_s.upcase.ljust(5)} Taski: #{message}"
-
-      unless context.empty?
-        context_parts = context.map do |key, value|
-          "#{key}=#{format_value(value)}"
-        end
-        line += " (#{context_parts.join(", ")})"
-      end
-
-      @output.puts line
-    end
-
-    # JSON log format for structured logging systems
-    def log_json(level, message, context)
-      require "json"
-
-      log_entry = {
-        timestamp: Time.now.iso8601(3),
-        level: level.to_s,
-        logger: "taski",
-        message: message,
-        elapsed_ms: ((Time.now - @start_time) * 1000).round(1)
-      }.merge(context)
-
-      @output.puts JSON.generate(log_entry)
-    end
-
-    # Format values for structured logging
-    def format_value(value)
-      case value
-      when String
-        (value.length > 50) ? "#{value[0..47]}..." : value
-      when Array
-        (value.size > 5) ? "[#{value[0..4].join(", ")}, ...]" : value.inspect
-      when Hash
-        (value.size > 3) ? "{#{value.keys[0..2].join(", ")}, ...}" : value.inspect
-      else
-        value.inspect
-      end
-    end
   end
 
   class << self
@@ -189,7 +134,7 @@ module Taski
     # Get the current progress display instance (always enabled)
     # @return [ProgressDisplay] Current progress display instance
     def progress_display
-      @progress_display ||= ProgressDisplay.new(force_enable: ENV["TASKI_FORCE_PROGRESS"] == "1")
+      @progress_display ||= ProgressDisplay.new
     end
 
     # Configure the logger with new settings

data/lib/taski/logging/formatter_factory.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "simple_formatter"
+require_relative "structured_formatter"
+require_relative "json_formatter"
+
+module Taski
+  module Logging
+    # Factory for creating log formatters
+    class FormatterFactory
+      # Create a formatter instance based on format symbol
+      # @param format [Symbol] Format type (:simple, :structured, :json)
+      # @return [FormatterInterface] Formatter instance
+      def self.create(format)
+        case format
+        when :simple
+          SimpleFormatter.new
+        when :structured
+          StructuredFormatter.new
+        when :json
+          JsonFormatter.new
+        else
+          raise ArgumentError, "Unknown format: #{format}. Valid formats: :simple, :structured, :json"
+        end
+      end
+
+      # Get list of available formats
+      # @return [Array<Symbol>] Available format symbols
+      def self.available_formats
+        [:simple, :structured, :json]
+      end
+    end
+  end
+end

data/lib/taski/logging/formatter_interface.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Taski
+  module Logging
+    # Interface for log formatters
+    # All formatters must implement the format method
+    module FormatterInterface
+      # Format a log entry
+      # @param level [Symbol] Log level (:debug, :info, :warn, :error)
+      # @param message [String] Log message
+      # @param context [Hash] Additional context information
+      # @param start_time [Time] Logger start time for elapsed calculation
+      # @return [String] Formatted log line
+      def format(level, message, context, start_time)
+        raise NotImplementedError, "Subclass must implement format method"
+      end
+    end
+  end
+end

data/lib/taski/logging/json_formatter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "formatter_interface"
+
+module Taski
+  module Logging
+    # JSON log formatter for structured logging systems
+    class JsonFormatter
+      include FormatterInterface
+
+      def format(level, message, context, start_time)
+        require "json"
+
+        log_entry = {
+          timestamp: Time.now.iso8601(3),
+          level: level.to_s,
+          logger: "taski",
+          message: message,
+          elapsed_ms: ((Time.now - start_time) * 1000).round(1)
+        }.merge(context)
+
+        JSON.generate(log_entry)
+      end
+    end
+  end
+end

data/lib/taski/logging/simple_formatter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "formatter_interface"
+
+module Taski
+  module Logging
+    # Simple log formatter: [LEVEL] message
+    class SimpleFormatter
+      include FormatterInterface
+
+      def format(level, message, context, start_time)
+        "[#{level.upcase}] #{message}"
+      end
+    end
+  end
+end

data/lib/taski/logging/structured_formatter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "formatter_interface"
+
+module Taski
+  module Logging
+    # Structured log formatter with timestamp and context
+    class StructuredFormatter
+      include FormatterInterface
+
+      def format(level, message, context, start_time)
+        timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S.%3N")
+        elapsed = ((Time.now - start_time) * 1000).round(1)
+
+        line = "[#{timestamp}] [#{elapsed}ms] #{level.to_s.upcase.ljust(5)} Taski: #{message}"
+
+        unless context.empty?
+          context_parts = context.map do |key, value|
+            "#{key}=#{format_value(value)}"
+          end
+          line += " (#{context_parts.join(", ")})"
+        end
+
+        line
+      end
+
+      private
+
+      # Format values for structured logging
+      def format_value(value)
+        case value
+        when String
+          (value.length > 50) ? "#{value[0..47]}..." : value
+        when Array
+          (value.size > 5) ? "[#{value[0..4].join(", ")}, ...]" : value.inspect
+        when Hash
+          (value.size > 3) ? "{#{value.keys[0..2].join(", ")}, ...}" : value.inspect
+        else
+          value.inspect
+        end
+      end
+    end
+  end
+end

data/lib/taski/progress/display_colors.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Taski
+  module Progress
+    # Color constants for progress display
+    module DisplayColors
+      COLORS = {
+        reset: "\033[0m",
+        bold: "\033[1m",
+        dim: "\033[2m",
+        cyan: "\033[36m",
+        green: "\033[32m",
+        red: "\033[31m"
+      }.freeze
+    end
+  end
+end

data/lib/taski/progress/display_manager.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "task_status"
+require_relative "task_formatter"
+
+module Taski
+  module Progress
+    # Manages the display state and coordinates display updates
+    class DisplayManager
+      def initialize(terminal, spinner, output_capture, include_captured_output: false)
+        @terminal = terminal
+        @spinner = spinner
+        @output_capture = output_capture
+        @include_captured_output = include_captured_output
+        @formatter = TaskFormatter.new
+        @completed_tasks = []
+        @current_display_lines = 0
+      end
+
+      def start_task_display(task_name)
+        clear_current_display
+        @output_capture.start
+        start_spinner_display(task_name)
+      end
+
+      def complete_task_display(task_name, duration:)
+        status = TaskStatus.new(name: task_name, duration: duration)
+        finish_task_display(status)
+      end
+
+      def fail_task_display(task_name, error:, duration:)
+        status = TaskStatus.new(name: task_name, duration: duration, error: error)
+        finish_task_display(status)
+      end
+
+      def clear_all_displays
+        @spinner.stop
+        @output_capture.stop
+        clear_current_display
+
+        # Display final summary of all completed tasks
+        if @completed_tasks.any?
+          @completed_tasks.each do |status|
+            @terminal.puts @formatter.format_completed_task(status)
+          end
+          @terminal.flush
+        end
+
+        @completed_tasks.clear
+        @current_display_lines = 0
+      end
+
+      private
+
+      def start_spinner_display(task_name)
+        @spinner.start(@terminal, task_name) do |spinner_char, name|
+          display_current_state(spinner_char, name)
+        end
+      end
+
+      def display_current_state(spinner_char, task_name)
+        clear_current_display
+
+        lines_count = 0
+
+        # Only display current task with spinner (no past completed tasks during execution)
+        @terminal.puts @formatter.format_current_task(spinner_char, task_name)
+        lines_count += 1
+
+        # Display output lines
+        @output_capture.last_lines.each do |line|
+          @terminal.puts @formatter.format_output_line(line)
+          lines_count += 1
+        end
+
+        @current_display_lines = lines_count
+        @terminal.flush
+      end
+
+      def finish_task_display(status)
+        @spinner.stop
+
+        # Capture output before stopping
+        captured_output = @output_capture.last_lines
+        @output_capture.stop
+        clear_current_display
+
+        # Include captured output if requested (typically for test environments)
+        if @include_captured_output && captured_output.any?
+          captured_output.each do |line|
+            @terminal.puts line.chomp
+          end
+        end
+
+        @completed_tasks << status
+        display_final_state
+      end
+
+      def display_final_state
+        # Only display the newly completed task (last one)
+        if @completed_tasks.any?
+          latest_task = @completed_tasks.last
+          @terminal.puts @formatter.format_completed_task(latest_task)
+        end
+        @terminal.flush
+        @current_display_lines = 1  # Only one line for the latest task
+      end
+
+      def clear_current_display
+        @terminal.clear_lines(@current_display_lines)
+        @current_display_lines = 0
+      end
+    end
+  end
+end

data/lib/taski/progress/output_capture.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Taski
+  module Progress
+    # Captures stdout and maintains last N lines like tail -f
+    class OutputCapture
+      MAX_LINES = 10
+      DISPLAY_LINES = 5
+
+      def initialize(main_output)
+        @main_output = main_output
+        @buffer = []
+        @capturing = false
+        @original_stdout = nil
+        @pipe_reader = nil
+        @pipe_writer = nil
+        @capture_thread = nil
+      end
+
+      def start
+        return if @capturing
+
+        @buffer.clear
+        setup_stdout_redirection
+        @capturing = true
+
+        start_capture_thread
+      end
+
+      def stop
+        return unless @capturing
+
+        @capturing = false
+
+        # Restore stdout
+        restore_stdout
+
+        # Clean up pipes and thread
+        cleanup_capture_thread
+        cleanup_pipes
+      end
+
+      def last_lines
+        @buffer.last(DISPLAY_LINES)
+      end
+
+      def capturing?
+        @capturing
+      end
+
+      private
+
+      def setup_stdout_redirection
+        @original_stdout = $stdout
+        @pipe_reader, @pipe_writer = IO.pipe
+        $stdout = @pipe_writer
+      end
+
+      def restore_stdout
+        return unless @original_stdout
+
+        $stdout = @original_stdout
+        @original_stdout = nil
+      end
+
+      def start_capture_thread
+        @capture_thread = Thread.new do
+          while (line = @pipe_reader.gets)
+            line = line.chomp
+            next if line.empty?
+            next if skip_line?(line)
+
+            add_line_to_buffer(line)
+          end
+        rescue IOError
+          # Pipe closed, normal termination
+        end
+      end
+
+      def skip_line?(line)
+        # Skip logger lines (they appear separately)
+        line.match?(/^\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}\]/)
+      end
+
+      def add_line_to_buffer(line)
+        @buffer << line
+        @buffer.shift while @buffer.length > MAX_LINES
+      end
+
+      def cleanup_capture_thread
+        @capture_thread&.join(0.1)
+        @capture_thread = nil
+      end
+
+      def cleanup_pipes
+        [@pipe_writer, @pipe_reader].each do |pipe|
+          pipe&.close
+        rescue IOError
+          # Already closed, ignore
+        end
+        @pipe_writer = @pipe_reader = nil
+      end
+    end
+  end
+end