taski 0.3.0 → 0.4.0

data/lib/taski/tree_colors.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module Taski
-  # Color utilities for tree display
-  # Provides ANSI color codes for enhanced tree visualization
-  class TreeColors
-    # ANSI color codes
-    COLORS = {
-      red: "\e[31m",
-      green: "\e[32m",
-      yellow: "\e[33m",
-      blue: "\e[34m",
-      magenta: "\e[35m",
-      cyan: "\e[36m",
-      gray: "\e[90m",
-      reset: "\e[0m",
-      bold: "\e[1m"
-    }.freeze
-
-    class << self
-      # Check if colors should be enabled
-      # @return [Boolean] true if colors should be used
-      def enabled?
-        return @enabled unless @enabled.nil?
-        @enabled = tty? && !no_color?
-      end
-
-      # Enable or disable colors
-      # @param value [Boolean] whether to enable colors
-      attr_writer :enabled
-
-      # Colorize text for Section names (blue)
-      # @param text [String] text to colorize
-      # @return [String] colorized text
-      def section(text)
-        colorize(text, :blue, bold: true)
-      end
-
-      # Colorize text for Task names (green)
-      # @param text [String] text to colorize
-      # @return [String] colorized text
-      def task(text)
-        colorize(text, :green)
-      end
-
-      # Colorize text for implementation candidates (yellow)
-      # @param text [String] text to colorize
-      # @return [String] colorized text
-      def implementations(text)
-        colorize(text, :yellow)
-      end
-
-      # Colorize tree connectors (gray)
-      # @param text [String] text to colorize
-      # @return [String] colorized text
-      def connector(text)
-        colorize(text, :gray)
-      end
-
-      private
-
-      # Apply color to text
-      # @param text [String] text to colorize
-      # @param color [Symbol] color name
-      # @param bold [Boolean] whether to make text bold
-      # @return [String] colorized text
-      def colorize(text, color, bold: false)
-        return text unless enabled?
-
-        result = ""
-        result += COLORS[:bold] if bold
-        result += COLORS[color]
-        result += text
-        result += COLORS[:reset]
-        result
-      end
-
-      # Check if output is a TTY
-      # @return [Boolean] true if stdout is a TTY
-      def tty?
-        $stdout.tty?
-      end
-
-      # Check if NO_COLOR environment variable is set
-      # @return [Boolean] true if colors should be disabled
-      def no_color?
-        ENV.key?("NO_COLOR")
-      end
-    end
-  end
-end

data/lib/taski/utils/dependency_resolver_helper.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module Taski
-  module Utils
-    # Helper module for dependency resolution functionality
-    # Provides common logic for resolving dependencies and detecting circular dependencies
-    module DependencyResolverHelper
-      private
-
-      # Resolve all dependencies in topological order with circular dependency detection
-      # @return [Array<Class>] Array of tasks in dependency order
-      def resolve_dependencies_common
-        queue = [self]
-        resolved = []
-        visited = Set.new
-        resolving = Set.new
-        path_map = {self => []}
-
-        while queue.any?
-          task_class = queue.shift
-          next if visited.include?(task_class)
-
-          if resolving.include?(task_class)
-            cycle_path = build_cycle_path(task_class, path_map)
-            raise CircularDependencyError, build_circular_dependency_message(cycle_path)
-          end
-
-          resolving << task_class
-          visited << task_class
-
-          current_path = path_map[task_class] || []
-          task_class.resolve(queue, resolved)
-
-          task_class.instance_variable_get(:@dependencies)&.each do |dep|
-            dep_class = extract_class(dep)
-            path_map[dep_class] = current_path + [task_class] unless path_map.key?(dep_class)
-          end
-
-          resolving.delete(task_class)
-          resolved << task_class unless resolved.include?(task_class)
-        end
-
-        resolved
-      end
-
-      # Resolve method for dependency graph (called by resolve_dependencies)
-      # @param queue [Array] Queue of tasks to process
-      # @param resolved [Array] Array of resolved tasks
-      # @param options [Hash] Optional parameters for customization
-      # @return [self] Returns self for method chaining
-      def resolve_common(queue, resolved, options = {})
-        @dependencies ||= []
-
-        @dependencies.each do |task|
-          task_class = extract_class(task)
-
-          # Reorder in resolved list for correct priority
-          resolved.delete(task_class) if resolved.include?(task_class)
-          queue << task_class
-        end
-
-        # Call custom hook if provided
-        options[:custom_hook]&.call
-
-        self
-      end
-
-      # Build the cycle path from path tracking information
-      # @param task_class [Class] Current task class
-      # @param path_map [Hash] Map of paths to each task
-      # @return [Array] Cycle path array
-      def build_cycle_path(task_class, path_map)
-        path = path_map[task_class] || []
-        path + [task_class]
-      end
-
-      # Build detailed error message for circular dependencies
-      # @param cycle_path [Array] Array representing the circular dependency path
-      # @return [String] Formatted error message
-      def build_circular_dependency_message(cycle_path)
-        Utils::CircularDependencyHelpers.build_error_message(cycle_path, "dependency")
-      end
-    end
-  end
-end

data/lib/taski/utils/tree_display_helper.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module Taski
-  module Utils
-    # Helper module for tree display functionality
-    # Provides common logic for displaying dependency trees
-    module TreeDisplayHelper
-      private
-
-      # Render dependencies as tree structure
-      # @param dependencies [Array] Array of dependency objects
-      # @param prefix [String] Current indentation prefix
-      # @param visited [Set] Set of visited classes
-      # @param color [Boolean] Whether to use color output
-      # @return [String] Formatted dependency tree string
-      def render_dependencies_tree(dependencies, prefix, visited, color)
-        result = ""
-
-        dependencies = dependencies.uniq { |dep| extract_class(dep) }
-        dependencies.each_with_index do |dep, index|
-          dep_class = extract_class(dep)
-          is_last = index == dependencies.length - 1
-
-          connector_text = is_last ? "└── " : "├── "
-          connector = color ? TreeColors.connector(connector_text) : connector_text
-          child_prefix_text = is_last ? "    " : "│   "
-          child_prefix = prefix + (color ? TreeColors.connector(child_prefix_text) : child_prefix_text)
-
-          # For the dependency itself, we want to use the connector
-          # For its children, we want to use the child_prefix
-          dep_tree = if dep_class.respond_to?(:tree)
-            dep_class.tree(child_prefix, visited, color: color)
-          else
-            "#{child_prefix}#{dep_class.name}\n"
-          end
-
-          # Replace the first line (which has child_prefix) with the proper connector
-          dep_lines = dep_tree.lines
-          if dep_lines.any?
-            # Replace the first line prefix with connector
-            first_line = dep_lines[0]
-            fixed_first_line = first_line.sub(/^#{Regexp.escape(child_prefix)}/, prefix + connector)
-            result += fixed_first_line
-            # Add the rest of the lines as-is
-            result += dep_lines[1..].join if dep_lines.length > 1
-          else
-            dep_name = color ? TreeColors.task(dep_class.name) : dep_class.name
-            result += "#{prefix}#{connector}#{dep_name}\n"
-          end
-        end
-
-        result
-      end
-
-      # Check for circular dependencies and handle visited set
-      # @param visited [Set] Set of visited classes
-      # @param current_class [Class] Current class being processed
-      # @param prefix [String] Current indentation prefix
-      # @return [Array] Returns [should_return_early, result_string, new_visited_set]
-      def handle_circular_dependency_check(visited, current_class, prefix)
-        if visited.include?(current_class)
-          return [true, "#{prefix}#{current_class.name} (circular)\n", visited]
-        end
-
-        new_visited = visited.dup
-        new_visited << current_class
-        [false, nil, new_visited]
-      end
-    end
-  end
-end

data/lib/taski/utils.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module Taski
-  # Common utility functions for the Taski framework
-  module Utils
-    # Handle circular dependency error message generation
-    module CircularDependencyHelpers
-      # Build detailed error message for circular dependencies
-      # @param cycle_path [Array<Class>] The circular dependency path
-      # @param context [String] Context of the error (dependency, runtime)
-      # @return [String] Formatted error message
-      def self.build_error_message(cycle_path, context = "dependency")
-        path_names = cycle_path.map { |klass| klass.name || klass.to_s }
-
-        message = "Circular dependency detected!\n"
-        message += "Cycle: #{path_names.join(" → ")}\n\n"
-        message += "The #{context} chain is:\n"
-
-        cycle_path.each_cons(2).with_index do |(from, to), index|
-          action = (context == "dependency") ? "depends on" : "is trying to build"
-          message += "  #{index + 1}. #{from.name} #{action} → #{to.name}\n"
-        end
-
-        message += "\nThis creates an infinite loop that cannot be resolved." if context == "dependency"
-        message
-      end
-    end
-
-    # Common dependency utility functions
-    module DependencyUtils
-      # Extract class from dependency hash
-      # @param dep [Hash] Dependency information
-      # @return [Class] The dependency class
-      def extract_class(dep)
-        klass = dep[:klass]
-        klass.is_a?(Reference) ? klass.deref : klass
-      end
-    end
-
-    # Common task build utility functions
-    module TaskBuildHelpers
-      # Format arguments hash for display in error messages
-      # @param args [Hash] Arguments hash
-      # @return [String] Formatted arguments string
-      def self.format_args(args)
-        return "" if args.nil? || args.empty?
-
-        formatted_pairs = args.map do |key, value|
-          "#{key}: #{value.inspect}"
-        end
-        "{#{formatted_pairs.join(", ")}}"
-      end
-
-      # Execute block with comprehensive build logging and progress display
-      # @param task_name [String] Name of the task being built
-      # @param dependencies [Array] List of dependencies
-      # @param args [Hash] Build arguments for parametrized builds
-      # @yield Block to execute with logging
-      # @return [Object] Result of the block execution
-      def self.with_build_logging(task_name, dependencies: [], args: nil)
-        build_start_time = Time.now
-
-        begin
-          # Traditional logging first (before any stdout redirection)
-          Taski.logger.task_build_start(task_name, dependencies: dependencies, args: args)
-
-          # Show progress display if enabled (this may redirect stdout)
-          Taski.progress_display&.start_task(task_name, dependencies: dependencies)
-
-          result = yield
-          duration = Time.now - build_start_time
-
-          # Complete progress display first (this restores stdout)
-          Taski.progress_display&.complete_task(task_name, duration: duration)
-
-          # Then do logging (on restored stdout)
-          begin
-            Taski.logger.task_build_complete(task_name, duration: duration)
-          rescue IOError
-            # If logger fails due to closed stream, write to STDERR instead
-            warn "[#{Time.now.strftime("%Y-%m-%d %H:%M:%S.%3N")}] INFO  Taski: Task build completed (task=#{task_name}, duration_ms=#{(duration * 1000).round(2)})"
-          end
-
-          result
-        rescue => e
-          duration = Time.now - build_start_time
-
-          # Complete progress display first (with error)
-          Taski.progress_display&.fail_task(task_name, error: e, duration: duration)
-
-          # Then do error logging (on restored stdout)
-          begin
-            Taski.logger.task_build_failed(task_name, error: e, duration: duration)
-          rescue IOError
-            # If logger fails due to closed stream, write to STDERR instead
-            warn "[#{Time.now.strftime("%Y-%m-%d %H:%M:%S.%3N")}] ERROR Taski: Task build failed (task=#{task_name}, error=#{e.message}, duration_ms=#{(duration * 1000).round(2)})"
-          end
-
-          error_message = "Failed to build task #{task_name}"
-          error_message += " with args #{format_args(args)}" if args && !args.empty?
-          error_message += ": #{e.message}"
-          raise TaskBuildError, error_message
-        end
-      end
-    end
-  end
-end