taski 0.2.3 → 0.3.0

data/lib/taski/task/dependency_resolver.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../dependency_analyzer"
+require_relative "../utils/dependency_resolver_helper"
 
 module Taski
   class Task
@@ -12,75 +13,13 @@ module Taski
       # @param resolved [Array] Array of resolved tasks
       # @return [self] Returns self for method chaining
       def resolve(queue, resolved)
-        @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
-
-        # Create getter methods for defined values
-        create_defined_methods
-
-        self
+        resolve_common(queue, resolved, custom_hook: -> { create_defined_methods })
       end
 
       # Resolve all dependencies in topological order with circular dependency detection
       # @return [Array<Class>] Array of tasks in dependency order
       def resolve_dependencies
-        queue = [self]
-        resolved = []
-        visited = Set.new
-        resolving = Set.new  # Track currently resolving tasks
-        path_map = {self => []}  # Track paths to each task
-
-        while queue.any?
-          task_class = queue.shift
-          next if visited.include?(task_class)
-
-          # Check for circular dependency
-          if resolving.include?(task_class)
-            # Build error message with path information
-            cycle_path = build_cycle_path(task_class, path_map)
-            raise CircularDependencyError, build_circular_dependency_message(cycle_path)
-          end
-
-          resolving << task_class
-          visited << task_class
-
-          # Store current path for dependencies
-          current_path = path_map[task_class] || []
-
-          # Let task resolve its dependencies
-          task_class.resolve(queue, resolved)
-
-          # Track paths for each dependency
-          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
-
-      private
-
-      # Build the cycle path from path tracking information
-      def build_cycle_path(task_class, path_map)
-        path = path_map[task_class] || []
-        path + [task_class]
-      end
-
-      # Build detailed error message for circular dependencies
-      def build_circular_dependency_message(cycle_path)
-        Utils::CircularDependencyHelpers.build_error_message(cycle_path, "dependency")
+        resolve_dependencies_common
       end
 
       public
@@ -127,6 +66,7 @@ module Taski
       private
 
       include Utils::DependencyUtils
+      include Utils::DependencyResolverHelper
       private :extract_class
     end
   end

data/lib/taski/task/instance_management.rb

@@ -89,21 +89,8 @@ module Taski
           # Check again after acquiring lock
           return @__task_instance if @__task_instance
 
-          # Prevent infinite recursion using thread-local storage
-          thread_key = build_thread_key
-          if Thread.current[thread_key]
-            # Build dependency path for better error message
-            cycle_path = build_current_dependency_path
-            raise CircularDependencyError, build_runtime_circular_dependency_message(cycle_path)
-          end
-
-          Thread.current[thread_key] = true
-          begin
-            build_dependencies
-            @__task_instance = build_instance
-          ensure
-            Thread.current[thread_key] = false
-          end
+          check_circular_dependency
+          create_and_build_instance
         end
 
         @__task_instance
@@ -111,6 +98,32 @@ module Taski
 
       private
 
+      # === Instance Management Helper Methods ===
+
+      # Check for circular dependencies and raise error if detected
+      # @raise [CircularDependencyError] If circular dependency is detected
+      def check_circular_dependency
+        thread_key = build_thread_key
+        if Thread.current[thread_key]
+          # Build dependency path for better error message
+          cycle_path = build_current_dependency_path
+          raise CircularDependencyError, build_runtime_circular_dependency_message(cycle_path)
+        end
+      end
+
+      # Create and build instance with proper thread-local state management
+      # @return [void] Sets @__task_instance
+      def create_and_build_instance
+        thread_key = build_thread_key
+        Thread.current[thread_key] = true
+        begin
+          build_dependencies
+          @__task_instance = build_instance
+        ensure
+          Thread.current[thread_key] = false
+        end
+      end
+
       # === Core Helper Methods ===
 
       # Get or create build monitor for thread safety

data/lib/taski/tree_colors.rb

@@ -0,0 +1,91 @@
+# 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

@@ -0,0 +1,85 @@
+# 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

@@ -0,0 +1,71 @@
+# 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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Taski
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

data/lib/taski.rb

@@ -10,6 +10,7 @@ require_relative "taski/progress_display"
 require_relative "taski/reference"
 require_relative "taski/dependency_analyzer"
 require_relative "taski/utils"
+require_relative "taski/tree_colors"
 
 # Load Task class components
 require_relative "taski/task/base"
@@ -18,6 +19,9 @@ require_relative "taski/task/define_api"
 require_relative "taski/task/instance_management"
 require_relative "taski/task/dependency_resolver"
 
+# Load Section class
+require_relative "taski/section"
+
 module Taski
   # Main module for the Taski task framework
   #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taski
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - ahogappa
@@ -43,19 +43,36 @@ files:
 - examples/advanced_patterns.rb
 - examples/progress_demo.rb
 - examples/quick_start.rb
+- examples/section_configuration.rb
 - examples/tree_demo.rb
 - lib/taski.rb
 - lib/taski/dependency_analyzer.rb
 - lib/taski/exceptions.rb
 - lib/taski/logger.rb
+- lib/taski/logging/formatter_factory.rb
+- lib/taski/logging/formatter_interface.rb
+- lib/taski/logging/json_formatter.rb
+- lib/taski/logging/simple_formatter.rb
+- lib/taski/logging/structured_formatter.rb
+- lib/taski/progress/display_colors.rb
+- lib/taski/progress/display_manager.rb
+- lib/taski/progress/output_capture.rb
+- lib/taski/progress/spinner_animation.rb
+- lib/taski/progress/task_formatter.rb
+- lib/taski/progress/task_status.rb
+- lib/taski/progress/terminal_controller.rb
 - lib/taski/progress_display.rb
 - lib/taski/reference.rb
+- lib/taski/section.rb
 - lib/taski/task/base.rb
 - lib/taski/task/define_api.rb
 - lib/taski/task/dependency_resolver.rb
 - lib/taski/task/exports_api.rb
 - lib/taski/task/instance_management.rb
+- lib/taski/tree_colors.rb
 - lib/taski/utils.rb
+- lib/taski/utils/dependency_resolver_helper.rb
+- lib/taski/utils/tree_display_helper.rb
 - lib/taski/version.rb
 - sig/taski.rbs
 homepage: https://github.com/ahogappa/taski