taski 0.9.0 → 0.9.2

data/lib/taski/static_analysis/start_dep_analyzer.rb

@@ -0,0 +1,400 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Taski
+  module StaticAnalysis
+    # Analyzes a task's run method AST to find dependencies that are safe
+    # to speculatively pre-start (start_dep). Uses a whitelist approach:
+    # only confirmed patterns are collected; unknown patterns cause the
+    # analyzer to stop (returning what was collected so far up to that point).
+    #
+    # Currently handles variable assignment patterns only:
+    #   a = Dep.value        (LocalVariableWriteNode)
+    #   @a = Dep.value       (InstanceVariableWriteNode)
+    #
+    # This is a performance optimization only — if analysis fails or returns
+    # empty, tasks still work correctly via lazy Fiber pull (need_dep).
+    class StartDepAnalyzer
+      DepInfo = Data.define(:klass, :method_name)
+      AnalysisResult = Data.define(:start_deps, :sync_deps)
+
+      # AST node types that are known safe (not dependencies, won't stop scanning)
+      SAFE_TYPES = Set[
+        Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode,
+        Prism::ConstantReadNode, Prism::ConstantPathNode,
+        Prism::IntegerNode, Prism::FloatNode, Prism::StringNode,
+        Prism::SymbolNode, Prism::NilNode, Prism::TrueNode, Prism::FalseNode,
+        Prism::SelfNode
+      ].freeze
+
+      @cache = {}
+      @cache_mutex = Mutex.new
+
+      class << self
+        # Analyze a task class and return deps safe to prestart.
+        # Results are cached per task class.
+        # @param task_class [Class] The task class to analyze
+        # @return [Array<DepInfo>] Deduplicated list of safe dependencies
+        def analyze(task_class)
+          @cache_mutex.synchronize do
+            return @cache[task_class] if @cache.key?(task_class)
+          end
+
+          result = new.analyze(task_class)
+
+          @cache_mutex.synchronize do
+            @cache[task_class] ||= result
+          end
+        end
+
+        # Clear cache (for testing)
+        def clear_cache!
+          @cache_mutex.synchronize { @cache.clear }
+        end
+      end
+
+      EMPTY_RESULT = AnalysisResult.new(start_deps: Set.new.freeze, sync_deps: Set.new.freeze).freeze
+
+      def initialize
+        @deps = []
+        @seen_classes = Set.new
+      end
+
+      # Analyze a task class's run method and return safe-to-prestart deps
+      # and sync_dep_classes (deps whose proxy variables are used unsafely).
+      # @param task_class [Class] The task class to analyze
+      # @return [AnalysisResult]
+      def analyze(task_class)
+        @task_class = task_class
+        @exported_ivars = Set.new(task_class.exported_methods.map { |m| :"@#{m}" })
+        source_location = task_class.instance_method(:run).source_location
+        return EMPTY_RESULT unless source_location
+
+        file_path, _line = source_location
+        parse_result = Prism.parse_file(file_path)
+
+        run_node = find_run_method(parse_result.value, task_class)
+        return EMPTY_RESULT unless run_node&.body
+
+        scan_statements(run_node.body)
+        unsafe_classes = detect_unsafe_proxy_usage(run_node.body)
+        all_dep_classes = Set.new(@deps.map(&:klass))
+        start_deps = all_dep_classes - unsafe_classes
+        sync_deps = unsafe_classes
+        AnalysisResult.new(start_deps: start_deps, sync_deps: sync_deps)
+      rescue NameError
+        EMPTY_RESULT
+      end
+
+      private
+
+      # Find the def run node inside the target class
+      def find_run_method(program_node, task_class)
+        target_name = task_class.name
+        find_run_in_tree(program_node, [], target_name)
+      end
+
+      def find_run_in_tree(node, namespace_path, target_name)
+        case node
+        when Prism::ProgramNode
+          node.statements.body.each do |child|
+            result = find_run_in_tree(child, namespace_path, target_name)
+            return result if result
+          end
+        when Prism::ModuleNode
+          name = node.constant_path.slice
+          new_path = namespace_path + [name]
+          node.body&.body&.each do |child|
+            result = find_run_in_tree(child, new_path, target_name)
+            return result if result
+          end
+        when Prism::ClassNode
+          name = node.constant_path.slice
+          new_path = namespace_path + [name]
+          full_name = new_path.join("::")
+
+          node.body&.body&.each do |child|
+            if full_name == target_name
+              return child if child.is_a?(Prism::DefNode) && child.name == :run
+            else
+              result = find_run_in_tree(child, new_path, target_name)
+              return result if result
+            end
+          end
+        when Prism::StatementsNode
+          node.body.each do |child|
+            result = find_run_in_tree(child, namespace_path, target_name)
+            return result if result
+          end
+        end
+
+        nil
+      end
+
+      # Scan statements, collecting deps. Stops at the first unknown pattern.
+      def scan_statements(node)
+        return unless node.is_a?(Prism::StatementsNode)
+        node.body.each { |stmt| break unless try_match(stmt) }
+      end
+
+      # Match a statement against known patterns.
+      # Returns true to continue scanning, false to stop.
+      def try_match(stmt)
+        case stmt
+        when Prism::LocalVariableWriteNode, Prism::InstanceVariableWriteNode
+          check_dep_call(stmt.value)
+          true
+        when *SAFE_TYPES
+          true
+        else
+          false
+        end
+      end
+
+      # Check if a node is a Task dependency call (Constant.method) and collect it.
+      def check_dep_call(node)
+        return unless node.is_a?(Prism::CallNode)
+        return unless node.receiver
+
+        case node.receiver
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          constant_name = node.receiver.slice
+          resolved = resolve_constant(constant_name)
+          if resolved.is_a?(Class) && defined?(Taski::Task) && resolved < Taski::Task
+            collect_dep(node)
+          end
+        end
+      end
+
+      # Collect a dependency, deduplicating by class
+      def collect_dep(call_node)
+        constant_name = call_node.receiver.slice
+        method_name = call_node.name
+        klass = resolve_constant(constant_name)
+        return unless klass
+
+        @deps << DepInfo.new(klass: klass, method_name: method_name) if @seen_classes.add?(klass)
+      end
+
+      # Phase 2: Detect proxy variables used in unsafe contexts.
+      # Returns a Set of dep classes whose proxy variables are used unsafely.
+      # A proxy variable is a local variable assigned from a Taski::Task dep call
+      # (e.g., `a = Dep.value`). If such a variable is later used in an unsafe
+      # context (as argument, condition, array element, etc.), the dep class is
+      # added to sync_dep_classes so it will be resolved synchronously.
+      def detect_unsafe_proxy_usage(body_node)
+        proxy_vars = build_proxy_var_map(body_node)
+
+        unsafe_classes = Set.new
+        scan_for_unsafe_usage(body_node, proxy_vars, unsafe_classes)
+        unsafe_classes
+      end
+
+      # Build mapping of { local_var_name => dep_class } from assignment statements
+      def build_proxy_var_map(body_node)
+        proxy_vars = {}
+        return proxy_vars unless body_node.is_a?(Prism::StatementsNode)
+
+        body_node.body.each do |stmt|
+          next unless stmt.is_a?(Prism::LocalVariableWriteNode)
+
+          dep_class = extract_dep_class(stmt.value)
+          proxy_vars[stmt.name] = dep_class if dep_class
+        end
+        proxy_vars
+      end
+
+      # Extract the dep class from a call node if it's a Taski::Task dep call
+      def extract_dep_class(node)
+        return nil unless node.is_a?(Prism::CallNode)
+        return nil unless node.receiver
+
+        case node.receiver
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          constant_name = node.receiver.slice
+          resolved = resolve_constant(constant_name)
+          if resolved.is_a?(Class) && defined?(Taski::Task) && resolved < Taski::Task
+            resolved
+          end
+        end
+      end
+
+      # Recursively scan AST for unsafe proxy variable usage.
+      # Safe contexts: receiver of CallNode, string interpolation,
+      # RHS of local/ivar assignment. Everything else is unsafe.
+      def scan_for_unsafe_usage(node, proxy_vars, unsafe_classes) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        case node
+        when Prism::StatementsNode
+          node.body.each { |child| scan_for_unsafe_usage(child, proxy_vars, unsafe_classes) }
+
+        when Prism::LocalVariableWriteNode
+          if (dep_class = proxy_dep_class(node.value, proxy_vars))
+            # Reassignment or direct dep call: track the new variable name
+            proxy_vars[node.name] = dep_class
+          else
+            scan_for_unsafe_usage(node.value, proxy_vars, unsafe_classes)
+          end
+
+        when Prism::InstanceVariableWriteNode
+          if (dep_class = proxy_dep_class(node.value, proxy_vars))
+            if @exported_ivars.include?(node.name)
+              # @exported = proxy → safe (resolve_proxy_exports handles it)
+            else
+              # @non_exported = proxy → track for unsafe usage detection
+              proxy_vars[node.name] = dep_class
+            end
+          else
+            scan_for_unsafe_usage(node.value, proxy_vars, unsafe_classes)
+          end
+
+        when Prism::CallNode
+          # Receiver: proxy.foo → safe (method_missing fires)
+          if proxy_var_read?(node.receiver, proxy_vars)
+            # safe — don't flag receiver
+          elsif node.receiver
+            scan_for_unsafe_usage(node.receiver, proxy_vars, unsafe_classes)
+          end
+          # Arguments: foo(proxy) → UNSAFE
+          node.arguments&.arguments&.each do |arg|
+            if proxy_var_read?(arg, proxy_vars)
+              unsafe_classes.add(proxy_vars[arg.name])
+            else
+              scan_for_unsafe_usage(arg, proxy_vars, unsafe_classes)
+            end
+          end
+          scan_for_unsafe_usage(node.block, proxy_vars, unsafe_classes) if node.block
+
+        when Prism::IfNode
+          check_predicate_unsafe(node.predicate, proxy_vars, unsafe_classes)
+          scan_for_unsafe_usage(node.statements, proxy_vars, unsafe_classes) if node.statements
+          scan_for_unsafe_usage(node.subsequent, proxy_vars, unsafe_classes) if node.subsequent
+
+        when Prism::UnlessNode
+          check_predicate_unsafe(node.predicate, proxy_vars, unsafe_classes)
+          scan_for_unsafe_usage(node.statements, proxy_vars, unsafe_classes) if node.statements
+          scan_for_unsafe_usage(node.else_clause, proxy_vars, unsafe_classes) if node.else_clause
+
+        when Prism::WhileNode, Prism::UntilNode
+          check_predicate_unsafe(node.predicate, proxy_vars, unsafe_classes)
+          scan_for_unsafe_usage(node.statements, proxy_vars, unsafe_classes) if node.statements
+
+        when Prism::InterpolatedStringNode
+          node.parts.each do |part|
+            next unless part.is_a?(Prism::EmbeddedStatementsNode)
+
+            if part.statements&.body&.size == 1 &&
+                proxy_var_read?(part.statements.body[0], proxy_vars)
+              # safe — string interpolation calls to_s
+            else
+              scan_for_unsafe_usage(part, proxy_vars, unsafe_classes)
+            end
+          end
+
+        when Prism::EmbeddedStatementsNode
+          scan_for_unsafe_usage(node.statements, proxy_vars, unsafe_classes) if node.statements
+
+        when Prism::ArrayNode
+          node.elements.each do |elem|
+            if proxy_var_read?(elem, proxy_vars)
+              unsafe_classes.add(proxy_vars[elem.name])
+            else
+              scan_for_unsafe_usage(elem, proxy_vars, unsafe_classes)
+            end
+          end
+
+        when Prism::ElseNode
+          scan_for_unsafe_usage(node.statements, proxy_vars, unsafe_classes) if node.statements
+
+        when Prism::BeginNode
+          scan_for_unsafe_usage(node.statements, proxy_vars, unsafe_classes) if node.statements
+          scan_for_unsafe_usage(node.rescue_clause, proxy_vars, unsafe_classes) if node.rescue_clause
+          scan_for_unsafe_usage(node.ensure_clause, proxy_vars, unsafe_classes) if node.ensure_clause
+
+        when Prism::RescueNode
+          scan_for_unsafe_usage(node.statements, proxy_vars, unsafe_classes) if node.statements
+          scan_for_unsafe_usage(node.subsequent, proxy_vars, unsafe_classes) if node.subsequent
+
+        when Prism::EnsureNode
+          scan_for_unsafe_usage(node.statements, proxy_vars, unsafe_classes) if node.statements
+
+        when Prism::ParenthesesNode
+          scan_for_unsafe_usage(node.body, proxy_vars, unsafe_classes) if node.body
+
+        when Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode
+          # Bare proxy variable read in unknown context → UNSAFE
+          unsafe_classes.add(proxy_vars[node.name]) if proxy_vars.key?(node.name)
+
+        else
+          # For any unhandled node type, recurse into children (safety-first)
+          if node.respond_to?(:compact_child_nodes)
+            node.compact_child_nodes.each do |child|
+              scan_for_unsafe_usage(child, proxy_vars, unsafe_classes)
+            end
+          end
+        end
+      end
+
+      # Check if a predicate node is an unsafe proxy variable read
+      def check_predicate_unsafe(predicate, proxy_vars, unsafe_classes)
+        if proxy_var_read?(predicate, proxy_vars)
+          unsafe_classes.add(proxy_vars[predicate_key(predicate)])
+        else
+          scan_for_unsafe_usage(predicate, proxy_vars, unsafe_classes)
+        end
+      end
+
+      # Return the dep class if the node reads a proxy variable (local or ivar)
+      # or is a direct dep call. Returns nil otherwise.
+      def proxy_dep_class(node, proxy_vars)
+        if proxy_var_read?(node, proxy_vars)
+          proxy_vars[predicate_key(node)]
+        else
+          extract_dep_class(node)
+        end
+      end
+
+      # Check if node is a proxy variable read (local var or ivar)
+      def proxy_var_read?(node, proxy_vars)
+        case node
+        when Prism::LocalVariableReadNode
+          proxy_vars.key?(node.name)
+        when Prism::InstanceVariableReadNode
+          proxy_vars.key?(node.name)
+        else
+          false
+        end
+      end
+
+      # Extract the proxy_vars key from a variable read node
+      def predicate_key(node)
+        node.name
+      end
+
+      # Resolve a constant name to the class, with namespace fallback.
+      def resolve_constant(constant_name)
+        Object.const_get(constant_name)
+      rescue NameError
+        resolve_with_namespace(constant_name)
+      end
+
+      def resolve_with_namespace(constant_name)
+        return nil unless @task_class
+
+        namespace_parts = @task_class.name.split("::")
+        namespace_parts.length.downto(0) do |i|
+          prefix = namespace_parts.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
+    end
+  end
+end

data/lib/taski/task.rb

@@ -6,6 +6,7 @@ require_relative "execution/registry"
 require_relative "execution/task_wrapper"
 require_relative "progress/layout/tree"
 require_relative "progress/theme/plain"
+require_relative "task_proxy"
 
 module Taski
   # Base class for all tasks in the Taski framework.
@@ -114,7 +115,7 @@ module Taski
       def tree
         output = StringIO.new
         theme = Progress::Theme::Plain.new
-        layout = Progress::Layout::Tree.new(output: output, theme: theme)
+        layout = Progress::Layout::Tree.for(output: output, theme: theme)
         context = Execution::ExecutionFacade.new(root_task_class: self)
         layout.context = context
         layout.on_ready
@@ -181,12 +182,16 @@ module Taski
           registry = Taski.current_registry
           if registry
             if Thread.current[:taski_fiber_context]
-              # Fiber-based lazy resolution - yield to the worker loop
-              result = Fiber.yield([:need_dep, self, method])
-              if result.is_a?(Array) && result[0] == :_taski_error
-                raise result[1]
+              start_deps = Thread.current[:taski_start_deps]
+              if start_deps&.include?(self)
+                # Lazy resolution via proxy - safe dep confirmed by static analysis
+                TaskProxy.new(self, method)
+              else
+                # Synchronous resolution: dep not in allowlist (unknown or unsafe usage)
+                result = Fiber.yield(Taski::Execution::FiberProtocol::NeedDep.new(self, method))
+                raise result.error if result in Taski::Execution::FiberProtocol::DepError
+                result
               end
-              result
             else
               # Synchronous resolution (clean phase, outside Fiber)
               wrapper = registry.get_or_create(self) do

data/lib/taski/task_proxy.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Taski
+  # Lazy proxy that defers dependency resolution until the value is actually used.
+  # Inherits from BasicObject to minimize available methods, maximizing method_missing delegation.
+  class TaskProxy < BasicObject
+    def initialize(task_class, method)
+      @task_class = task_class
+      @method = method
+      @resolved = false
+      @value = nil
+      @error = nil
+    end
+
+    def __resolve__
+      ::Kernel.raise @error if @error
+      return @value if @resolved
+      @value = ::Fiber.yield(::Taski::Execution::FiberProtocol::NeedDep.new(@task_class, @method))
+      if @value in ::Taski::Execution::FiberProtocol::DepError
+        @error = @value.error
+        ::Kernel.raise @error
+      end
+      @resolved = true
+      @value
+    end
+
+    def __taski_proxy_resolve__
+      __resolve__
+    end
+
+    def method_missing(name, *args, **kwargs, &block)
+      __resolve__.__send__(name, *args, **kwargs, &block)
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      name == :__taski_proxy_resolve__ || __resolve__.respond_to?(name, include_private)
+    end
+
+    def !
+      !__resolve__
+    end
+
+    def ==(other)
+      __resolve__ == other
+    end
+
+    def !=(other)
+      __resolve__ != other
+    end
+
+    def equal?(other)
+      __resolve__.equal?(other)
+    end
+
+    def respond_to?(name, include_private = false)
+      name == :__taski_proxy_resolve__ || __resolve__.respond_to?(name, include_private)
+    end
+  end
+end

data/lib/taski/test_helper.rb

@@ -69,7 +69,7 @@ module Taski
 
         if MockRegistry.mock_for(task_class)
           wrapper.mark_completed(nil) unless wrapper.completed?
-          @completion_queue.push({task_class: task_class, wrapper: wrapper})
+          @completion_queue.push(Taski::Execution::FiberProtocol::TaskCompleted.new(task_class, wrapper))
           return
         end
 

data/lib/taski/version.rb

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

data/lib/taski.rb

@@ -4,6 +4,8 @@ require_relative "taski/version"
 require_relative "taski/static_analysis/analyzer"
 require_relative "taski/static_analysis/visitor"
 require_relative "taski/static_analysis/dependency_graph"
+require_relative "taski/static_analysis/start_dep_analyzer"
+require_relative "taski/execution/fiber_protocol"
 require_relative "taski/execution/registry"
 require_relative "taski/execution/task_observer"
 require_relative "taski/execution/execution_facade"
@@ -14,6 +16,7 @@ require_relative "taski/execution/executor"
 require_relative "taski/progress/layout/log"
 require_relative "taski/progress/layout/simple"
 require_relative "taski/progress/layout/tree"
+require_relative "taski/progress/config"
 require_relative "taski/args"
 require_relative "taski/env"
 require_relative "taski/logging"
@@ -265,14 +268,28 @@ module Taski
     reset_args! if created_args
   end
 
-  NOT_CONFIGURED = Object.new.freeze
   PROGRESS_MONITOR = Monitor.new
-  @progress_display = NOT_CONFIGURED
+  PROGRESS_NOT_SET = Object.new.freeze
+  @progress_display = PROGRESS_NOT_SET
+  @progress_config = Progress::Config.new {
+    PROGRESS_MONITOR.synchronize do
+      unless @progress_display.equal?(PROGRESS_NOT_SET)
+        @progress_display.stop if @progress_display.respond_to?(:stop)
+      end
+      @progress_display = PROGRESS_NOT_SET
+    end
+  }
+
+  # Get the progress configuration singleton.
+  # @return [Progress::Config]
+  def self.progress
+    PROGRESS_MONITOR.synchronize { @progress_config }
+  end
 
   def self.progress_display
     PROGRESS_MONITOR.synchronize do
-      if @progress_display.equal?(NOT_CONFIGURED)
-        @progress_display = Progress::Layout::Simple.new
+      if @progress_display.equal?(PROGRESS_NOT_SET)
+        @progress_display = @progress_config.build
       end
       @progress_display
     end
@@ -280,7 +297,7 @@ module Taski
 
   def self.progress_display=(display)
     PROGRESS_MONITOR.synchronize do
-      unless @progress_display.equal?(NOT_CONFIGURED)
+      unless @progress_display.equal?(PROGRESS_NOT_SET)
         @progress_display.stop if @progress_display.respond_to?(:stop)
       end
       @progress_display = display
@@ -289,10 +306,11 @@ module Taski
 
   def self.reset_progress_display!
     PROGRESS_MONITOR.synchronize do
-      unless @progress_display.equal?(NOT_CONFIGURED)
+      unless @progress_display.equal?(PROGRESS_NOT_SET)
         @progress_display.stop if @progress_display.respond_to?(:stop)
       end
-      @progress_display = NOT_CONFIGURED
+      @progress_display = PROGRESS_NOT_SET
+      @progress_config.reset
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taski
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.2
 platform: ruby
 authors:
 - ahogappa
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: liquid
   requirement: !ruby/object:Gem::Requirement
@@ -84,6 +98,7 @@ files:
 - lib/taski/env.rb
 - lib/taski/execution/execution_facade.rb
 - lib/taski/execution/executor.rb
+- lib/taski/execution/fiber_protocol.rb
 - lib/taski/execution/registry.rb
 - lib/taski/execution/scheduler.rb
 - lib/taski/execution/task_observer.rb
@@ -92,6 +107,7 @@ files:
 - lib/taski/execution/task_wrapper.rb
 - lib/taski/execution/worker_pool.rb
 - lib/taski/logging.rb
+- lib/taski/progress/config.rb
 - lib/taski/progress/layout/base.rb
 - lib/taski/progress/layout/filters.rb
 - lib/taski/progress/layout/log.rb
@@ -99,6 +115,9 @@ files:
 - lib/taski/progress/layout/tags.rb
 - lib/taski/progress/layout/theme_drop.rb
 - lib/taski/progress/layout/tree.rb
+- lib/taski/progress/layout/tree/event.rb
+- lib/taski/progress/layout/tree/live.rb
+- lib/taski/progress/layout/tree/structure.rb
 - lib/taski/progress/theme/base.rb
 - lib/taski/progress/theme/compact.rb
 - lib/taski/progress/theme/default.rb
@@ -106,8 +125,10 @@ files:
 - lib/taski/progress/theme/plain.rb
 - lib/taski/static_analysis/analyzer.rb
 - lib/taski/static_analysis/dependency_graph.rb
+- lib/taski/static_analysis/start_dep_analyzer.rb
 - lib/taski/static_analysis/visitor.rb
 - lib/taski/task.rb
+- lib/taski/task_proxy.rb
 - lib/taski/test_helper.rb
 - lib/taski/test_helper/errors.rb
 - lib/taski/test_helper/minitest.rb