taski 0.3.1 → 0.4.1

data/lib/taski/static_analysis/dependency_graph.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "tsort"
+
+module Taski
+  module StaticAnalysis
+    # Builds a complete dependency graph from a root task class
+    # and provides topological sorting with cycle detection.
+    class DependencyGraph
+      include TSort
+
+      def initialize
+        @graph = {}
+      end
+
+      # Build dependency graph starting from root task class
+      # @param root_task_class [Class] The root task class to analyze
+      # @return [DependencyGraph] self for method chaining
+      def build_from(root_task_class)
+        collect_dependencies(root_task_class)
+        self
+      end
+
+      # Get topologically sorted task classes (dependencies first)
+      # @return [Array<Class>] Sorted task classes
+      # @raise [TSort::Cyclic] If circular dependency is detected
+      def sorted
+        tsort
+      end
+
+      # Check if the graph contains circular dependencies
+      # @return [Boolean] true if circular dependencies exist
+      def cyclic?
+        tsort
+        false
+      rescue TSort::Cyclic
+        true
+      end
+
+      # Get strongly connected components (useful for debugging cycles)
+      # @return [Array<Array<Class>>] Groups of mutually dependent classes
+      def strongly_connected_components
+        each_strongly_connected_component.to_a
+      end
+
+      # Get task classes involved in cycles
+      # @return [Array<Array<Class>>] Only components with size > 1 (cycles)
+      def cyclic_components
+        strongly_connected_components.select { |component| component.size > 1 }
+      end
+
+      # Get all task classes in the graph
+      # @return [Array<Class>] All registered task classes
+      def all_tasks
+        @graph.keys
+      end
+
+      # Get direct dependencies for a task class
+      # @param task_class [Class] The task class
+      # @return [Set<Class>] Direct dependencies
+      def dependencies_for(task_class)
+        @graph.fetch(task_class, Set.new)
+      end
+
+      # TSort interface: iterate over all nodes
+      def tsort_each_node(&block)
+        @graph.each_key(&block)
+      end
+
+      # TSort interface: iterate over children (dependencies) of a node
+      def tsort_each_child(node, &block)
+        @graph.fetch(node, Set.new).each(&block)
+      end
+
+      private
+
+      # Recursively collect all dependencies starting from a task class
+      def collect_dependencies(task_class)
+        return if @graph.key?(task_class)
+
+        dependencies = Analyzer.analyze(task_class)
+        @graph[task_class] = dependencies
+
+        dependencies.each do |dep_class|
+          collect_dependencies(dep_class)
+        end
+      end
+    end
+  end
+end

data/lib/taski/static_analysis/visitor.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Taski
+  module StaticAnalysis
+    class Visitor < Prism::Visitor
+      attr_reader :dependencies
+
+      def initialize(target_task_class, target_method = :run)
+        super()
+        @target_task_class = target_task_class
+        @target_method = target_method
+        @dependencies = Set.new
+        @in_target_method = false
+        @current_namespace_path = []
+      end
+
+      def visit_class_node(node)
+        within_namespace(extract_constant_name(node.constant_path)) { super }
+      end
+
+      def visit_module_node(node)
+        within_namespace(extract_constant_name(node.constant_path)) { super }
+      end
+
+      def visit_def_node(node)
+        if node.name == @target_method && in_target_class?
+          @in_target_method = true
+          super
+          @in_target_method = false
+        else
+          super
+        end
+      end
+
+      def visit_call_node(node)
+        detect_task_dependency(node) if @in_target_method
+        super
+      end
+
+      def visit_constant_read_node(node)
+        detect_return_constant(node) if @in_target_method && @target_method == :impl
+        super
+      end
+
+      def visit_constant_path_node(node)
+        detect_return_constant(node) if @in_target_method && @target_method == :impl
+        super
+      end
+
+      private
+
+      def within_namespace(name)
+        @current_namespace_path.push(name)
+        yield
+      ensure
+        @current_namespace_path.pop
+      end
+
+      def in_target_class?
+        @current_namespace_path.join("::") == @target_task_class.name
+      end
+
+      def extract_constant_name(node)
+        node.slice
+      end
+
+      def detect_task_dependency(node)
+        return unless node.receiver
+
+        constant_name = extract_receiver_constant(node.receiver)
+        resolve_and_add_dependency(constant_name) if constant_name
+      end
+
+      def detect_return_constant(node)
+        constant_name = node.slice
+        resolve_and_add_dependency(constant_name)
+      end
+
+      def extract_receiver_constant(receiver)
+        case receiver
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          receiver.slice
+        end
+      end
+
+      def resolve_and_add_dependency(constant_name)
+        task_class = resolve_constant(constant_name)
+        @dependencies.add(task_class) if task_class && valid_dependency?(task_class)
+      end
+
+      def resolve_constant(constant_name)
+        Object.const_get(constant_name)
+      rescue NameError
+        resolve_with_namespace_prefix(constant_name)
+      end
+
+      def resolve_with_namespace_prefix(constant_name)
+        return nil if @current_namespace_path.empty?
+
+        @current_namespace_path.length.downto(0) do |i|
+          prefix = @current_namespace_path.take(i).join("::")
+          full_name = prefix.empty? ? constant_name : "#{prefix}::#{constant_name}"
+
+          begin
+            return Object.const_get(full_name)
+          rescue NameError
+            next
+          end
+        end
+
+        nil
+      end
+
+      def valid_dependency?(klass)
+        klass.is_a?(Class) &&
+          (is_parallel_task?(klass) || is_parallel_section?(klass))
+      end
+
+      def is_parallel_task?(klass)
+        defined?(Taski::Task) && klass < Taski::Task
+      end
+
+      def is_parallel_section?(klass)
+        defined?(Taski::Section) && klass < Taski::Section
+      end
+    end
+  end
+end

data/lib/taski/task.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require_relative "static_analysis/analyzer"
+require_relative "execution/registry"
+require_relative "execution/coordinator"
+require_relative "execution/task_wrapper"
+
+module Taski
+  class Task
+    class << self
+      def exports(*export_methods)
+        @exported_methods = export_methods
+
+        export_methods.each do |method|
+          define_instance_reader(method)
+          define_class_accessor(method)
+        end
+      end
+
+      def exported_methods
+        @exported_methods ||= []
+      end
+
+      # Each call creates a fresh TaskWrapper instance for re-execution support.
+      # Use class methods (e.g., MyTask.result) for cached single execution.
+      def new
+        Execution::TaskWrapper.new(
+          super,
+          registry: registry,
+          coordinator: coordinator
+        )
+      end
+
+      def cached_dependencies
+        @dependencies_cache ||= StaticAnalysis::Analyzer.analyze(self)
+      end
+
+      def clear_dependency_cache
+        @dependencies_cache = nil
+      end
+
+      def run(context: {})
+        Taski.start_context(options: context, root_task: self)
+        validate_no_circular_dependencies!
+        cached_wrapper.run
+      end
+
+      def clean(context: {})
+        Taski.start_context(options: context, root_task: self)
+        validate_no_circular_dependencies!
+        cached_wrapper.clean
+      end
+
+      def registry
+        Taski.global_registry
+      end
+
+      def coordinator
+        @coordinator ||= Execution::Coordinator.new(
+          registry: registry,
+          analyzer: StaticAnalysis::Analyzer
+        )
+      end
+
+      def reset!
+        registry.reset!
+        Taski.reset_global_registry!
+        Taski.reset_context!
+        @coordinator = nil
+        @circular_dependency_checked = false
+      end
+
+      def tree
+        build_tree(self, "", Set.new, false)
+      end
+
+      private
+
+      # ANSI color codes
+      COLORS = {
+        reset: "\e[0m",
+        task: "\e[32m",      # green
+        section: "\e[34m",   # blue
+        impl: "\e[33m",      # yellow
+        tree: "\e[90m",      # gray
+        name: "\e[1m"        # bold
+      }.freeze
+
+      def build_tree(task_class, prefix, visited, is_impl)
+        type_label = colored_type_label(task_class)
+        impl_prefix = is_impl ? "#{COLORS[:impl]}[impl]#{COLORS[:reset]} " : ""
+        name = "#{COLORS[:name]}#{task_class.name}#{COLORS[:reset]}"
+        result = "#{impl_prefix}#{name} #{type_label}\n"
+        return result if visited.include?(task_class)
+
+        visited.add(task_class)
+        dependencies = task_class.cached_dependencies.to_a
+        is_section = section_class?(task_class)
+
+        dependencies.each_with_index do |dep, index|
+          is_last = (index == dependencies.size - 1)
+          result += format_dependency_branch(dep, prefix, is_last, visited, is_section)
+        end
+
+        result
+      end
+
+      def format_dependency_branch(dep, prefix, is_last, visited, is_impl)
+        connector, extension = tree_connector_chars(is_last)
+        dep_tree = build_tree(dep, "#{prefix}#{extension}", visited, is_impl)
+
+        result = "#{prefix}#{COLORS[:tree]}#{connector}#{COLORS[:reset]}"
+        lines = dep_tree.lines
+        result += lines.first
+        lines.drop(1).each { |line| result += line }
+        result
+      end
+
+      def tree_connector_chars(is_last)
+        if is_last
+          ["└── ", "    "]
+        else
+          ["├── ", "│   "]
+        end
+      end
+
+      def colored_type_label(klass)
+        if section_class?(klass)
+          "#{COLORS[:section]}(Section)#{COLORS[:reset]}"
+        else
+          "#{COLORS[:task]}(Task)#{COLORS[:reset]}"
+        end
+      end
+
+      def section_class?(klass)
+        defined?(Taski::Section) && klass < Taski::Section
+      end
+
+      # Use allocate + initialize instead of new to avoid infinite loop
+      # since new is overridden to return TaskWrapper
+      def cached_wrapper
+        registry.get_or_create(self) do
+          task_instance = allocate
+          task_instance.send(:initialize)
+          Execution::TaskWrapper.new(
+            task_instance,
+            registry: registry,
+            coordinator: coordinator
+          )
+        end
+      end
+
+      def define_instance_reader(method)
+        undef_method(method) if method_defined?(method)
+
+        define_method(method) do
+          # @type self: Task
+          instance_variable_get("@#{method}")
+        end
+      end
+
+      def define_class_accessor(method)
+        singleton_class.undef_method(method) if singleton_class.method_defined?(method)
+
+        define_singleton_method(method) do
+          Taski.start_context(options: {}, root_task: self)
+          validate_no_circular_dependencies!
+          cached_wrapper.get_exported_value(method)
+        end
+      end
+
+      def validate_no_circular_dependencies!
+        return if @circular_dependency_checked
+
+        graph = StaticAnalysis::DependencyGraph.new.build_from(self)
+        cyclic_components = graph.cyclic_components
+
+        if cyclic_components.any?
+          raise Taski::CircularDependencyError.new(cyclic_components)
+        end
+
+        @circular_dependency_checked = true
+      end
+    end
+
+    def run
+      raise NotImplementedError, "Subclasses must implement the run method"
+    end
+
+    def clean
+    end
+
+    def reset!
+      self.class.exported_methods.each do |method|
+        instance_variable_set("@#{method}", nil)
+      end
+    end
+  end
+end

data/lib/taski/version.rb

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

data/lib/taski.rb

@@ -1,46 +1,75 @@
 # frozen_string_literal: true
 
-require "monitor"
-
-# Load core components
 require_relative "taski/version"
-require_relative "taski/exceptions"
-require_relative "taski/logger"
-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"
-require_relative "taski/task/exports_api"
-require_relative "taski/task/define_api"
-require_relative "taski/task/instance_management"
-require_relative "taski/task/dependency_resolver"
-
-# Load Section class
+require_relative "taski/static_analysis/analyzer"
+require_relative "taski/static_analysis/visitor"
+require_relative "taski/static_analysis/dependency_graph"
+require_relative "taski/execution/registry"
+require_relative "taski/execution/coordinator"
+require_relative "taski/execution/task_wrapper"
+require_relative "taski/execution/parallel_progress_display"
+require_relative "taski/context"
+require_relative "taski/task"
 require_relative "taski/section"
 
 module Taski
-  # Main module for the Taski task framework
-  #
-  # Taski provides a framework for defining and managing task dependencies
-  # with three complementary APIs:
-  # 1. Exports API - Export instance variables as class methods (static dependencies)
-  # 2. Define API - Define lazy-evaluated values with dynamic dependency resolution
-  # 3. Section API - Abstraction layers with runtime implementation selection
-  #
-  # API Selection Guide:
-  # - Use Exports API for simple static dependencies
-  # - Use Define API for conditional dependencies analyzed at class definition time
-  # - Use Section API for environment-specific implementations with static analysis
-  #
-  # Features:
-  # - Automatic dependency resolution (static and dynamic)
-  # - Static analysis of method dependencies
-  # - Runtime implementation selection with Section API
-  # - Thread-safe task building
-  # - Circular dependency detection
-  # - Memory leak prevention
+  class TaskAbortException < StandardError
+  end
+
+  # Raised when circular dependencies are detected between tasks
+  class CircularDependencyError < StandardError
+    attr_reader :cyclic_tasks
+
+    # @param cyclic_tasks [Array<Array<Class>>] Groups of mutually dependent task classes
+    def initialize(cyclic_tasks)
+      @cyclic_tasks = cyclic_tasks
+      task_names = cyclic_tasks.map { |group| group.map(&:name).join(" <-> ") }.join(", ")
+      super("Circular dependency detected: #{task_names}")
+    end
+  end
+
+  @context_monitor = Monitor.new
+
+  # Get the current execution context
+  # @return [Context, nil] The current context or nil if no task is running
+  def self.context
+    @context_monitor.synchronize { @context }
+  end
+
+  # Start a new execution context (internal use only)
+  # @api private
+  def self.start_context(options:, root_task:)
+    @context_monitor.synchronize do
+      return if @context
+      @context = Context.new(options: options, root_task: root_task)
+    end
+  end
+
+  # Reset the execution context (internal use only)
+  # @api private
+  def self.reset_context!
+    @context_monitor.synchronize { @context = nil }
+  end
+
+  def self.global_registry
+    @global_registry ||= Execution::Registry.new
+  end
+
+  def self.reset_global_registry!
+    @global_registry = nil
+  end
+
+  def self.progress_display
+    return nil unless progress_enabled?
+    @progress_display ||= Execution::ParallelProgressDisplay.new
+  end
+
+  def self.progress_enabled?
+    ENV["TASKI_PROGRESS"] == "1" || ENV["TASKI_FORCE_PROGRESS"] == "1"
+  end
+
+  def self.reset_progress_display!
+    @progress_display&.stop
+    @progress_display = nil
+  end
 end

data/rbs_collection.lock.yaml

@@ -0,0 +1,116 @@
+---
+path: ".gem_rbs_collection"
+gems:
+- name: ast
+  version: '2.4'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3a33fa6f8e486f880c80ca401f2be1c1f621cf11
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: fileutils
+  version: '0'
+  source:
+    type: stdlib
+- name: io-console
+  version: '0'
+  source:
+    type: stdlib
+- name: json
+  version: '0'
+  source:
+    type: stdlib
+- name: minitest
+  version: '5.25'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3a33fa6f8e486f880c80ca401f2be1c1f621cf11
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: parallel
+  version: '1.20'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3a33fa6f8e486f880c80ca401f2be1c1f621cf11
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: parser
+  version: '3.2'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3a33fa6f8e486f880c80ca401f2be1c1f621cf11
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: pp
+  version: '0'
+  source:
+    type: stdlib
+- name: prettyprint
+  version: '0'
+  source:
+    type: stdlib
+- name: prism
+  version: 1.6.0
+  source:
+    type: rubygems
+- name: rainbow
+  version: '3.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3a33fa6f8e486f880c80ca401f2be1c1f621cf11
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: rake
+  version: '13.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3a33fa6f8e486f880c80ca401f2be1c1f621cf11
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: rdoc
+  version: '0'
+  source:
+    type: stdlib
+- name: regexp_parser
+  version: '2.8'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3a33fa6f8e486f880c80ca401f2be1c1f621cf11
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: rubocop
+  version: '1.57'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3a33fa6f8e486f880c80ca401f2be1c1f621cf11
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: rubocop-ast
+  version: '1.30'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3a33fa6f8e486f880c80ca401f2be1c1f621cf11
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: simplecov
+  version: '0.22'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 3a33fa6f8e486f880c80ca401f2be1c1f621cf11
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: tsort
+  version: '0'
+  source:
+    type: stdlib
+gemfile_lock_path: Gemfile.lock

data/rbs_collection.yaml

@@ -0,0 +1,19 @@
+# Download sources
+sources:
+  - type: git
+    name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# You can specify local directories as sources also.
+# - type: local
+#   path: path/to/your/local/repository
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+# gems:
+#   # If you want to avoid installing rbs files for gems, you can specify them here.
+#   - name: GEM_NAME
+#     ignore: true