taski 0.1.1 → 0.2.1

data/lib/taski/task/instance_management.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Taski
+  class Task
+    class << self
+      # === Lifecycle Management ===
+
+      # Build this task and all its dependencies
+      def build
+        resolve_dependencies.reverse_each do |task_class|
+          task_class.ensure_instance_built
+        end
+      end
+
+      # Clean this task and all its dependencies in reverse order
+      def clean
+        resolve_dependencies.each do |task_class|
+          # Get existing instance or create new one for cleaning
+          instance = task_class.instance_variable_get(:@__task_instance) || task_class.new
+          instance.clean
+        end
+      end
+
+      # Reset task instance and cached data to prevent memory leaks
+      # @return [self] Returns self for method chaining
+      def reset!
+        build_monitor.synchronize do
+          @__task_instance = nil
+          @__defined_values = nil
+          @__defined_for_resolve = nil
+          clear_thread_local_state
+        end
+        self
+      end
+
+      # Refresh task state (currently just resets)
+      # @return [self] Returns self for method chaining
+      def refresh
+        reset!
+      end
+
+      # === Instance Management ===
+
+      # Ensure task instance is built (public because called from build)
+      # @return [Task] The built task instance
+      def ensure_instance_built
+        # Use double-checked locking pattern for thread safety
+        return @__task_instance if @__task_instance
+
+        build_monitor.synchronize do
+          # 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
+        end
+
+        @__task_instance
+      end
+
+      private
+
+      # === Core Helper Methods ===
+
+      # Get or create build monitor for thread safety
+      # @return [Monitor] Thread-safe monitor object
+      def build_monitor
+        @__build_monitor ||= Monitor.new
+      end
+
+      # Generate thread key for recursion detection
+      # @return [String] Thread key for this task
+      def build_thread_key
+        "#{name}#{THREAD_KEY_SUFFIX}"
+      end
+
+      # Build and configure task instance
+      # @return [Task] Built task instance
+      def build_instance
+        instance = new
+        build_start_time = Time.now
+        begin
+          Taski.logger.task_build_start(name.to_s, dependencies: @dependencies || [])
+          instance.build
+          duration = Time.now - build_start_time
+          Taski.logger.task_build_complete(name.to_s, duration: duration)
+          instance
+        rescue => e
+          duration = Time.now - build_start_time
+          # Log the error with full context
+          Taski.logger.task_build_failed(name.to_s, error: e, duration: duration)
+          raise TaskBuildError, "Failed to build task #{name}: #{e.message}"
+        end
+      end
+
+      # Clear thread-local state for this task
+      def clear_thread_local_state
+        Thread.current.keys.each do |key|
+          Thread.current[key] = nil if key.to_s.include?(build_thread_key)
+        end
+      end
+
+      # === Dependency Management ===
+
+      # Build all dependencies of this task
+      def build_dependencies
+        resolve_dependencies
+
+        (@dependencies || []).each do |dep|
+          dep_class = extract_class(dep)
+          next if dep_class == self
+
+          dep_class.ensure_instance_built if dep_class.respond_to?(:ensure_instance_built)
+        end
+      end
+
+      # Build current dependency path from thread-local storage
+      # @return [Array<Class>] Array of classes in the current build path
+      def build_current_dependency_path
+        path = []
+        Thread.current.keys.each do |key|
+          if key.to_s.end_with?(THREAD_KEY_SUFFIX) && Thread.current[key]
+            class_name = key.to_s.sub(THREAD_KEY_SUFFIX, "")
+            begin
+              path << Object.const_get(class_name)
+            rescue NameError
+              # Skip if class not found
+            end
+          end
+        end
+        path << self
+      end
+
+      # Build runtime circular dependency error message
+      # @param cycle_path [Array<Class>] The circular dependency path
+      # @return [String] Formatted error message
+      def build_runtime_circular_dependency_message(cycle_path)
+        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 dependency chain is:\n"
+
+        cycle_path.each_cons(2).with_index do |(from, to), index|
+          message += "  #{index + 1}. #{from.name} is trying to build → #{to.name}\n"
+        end
+
+        message += "\nThis creates an infinite loop that cannot be resolved."
+        message
+      end
+
+      # 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
+  end
+end

data/lib/taski/version.rb

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

data/lib/taski.rb

@@ -1,143 +1,40 @@
 # frozen_string_literal: true
 
+require "monitor"
+
+# Load core components
 require_relative "taski/version"
+require_relative "taski/exceptions"
+require_relative "taski/logger"
+require_relative "taski/reference"
+require_relative "taski/dependency_analyzer"
+
+# 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"
 
 module Taski
-  class Reference
-    def initialize(klass)
-      @klass = klass
-    end
-
-    def deref
-      Object.const_get(@klass)
-    end
-
-    def inspect
-      "&#{@klass}"
-    end
-  end
-
-  class Task
-    class << self
-      def ref(klass)
-        ref = Reference.new(klass)
-        throw :unresolved, ref
-      end
-
-      def define(name, block, **options)
-        @dependencies ||= []
-        @definitions ||= {}
-
-        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def self.#{name}
-            __resolve__[__callee__] ||= false
-            if __resolve__[__callee__]
-              # already resolved
-            else
-              __resolve__[__callee__] = true
-              throw :unresolved, [self, __callee__]
-            end
-          end
-        RUBY
-
-        classes = []
-        loop do
-          klass, task = catch(:unresolved) do
-            block.call
-            nil
-          end
-
-          if klass.nil?
-            classes.each do |task_class|
-              task_class[:klass].class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-                __resolve__ = {}
-              RUBY
-            end
-
-            break
-          else
-            classes << { klass:, task: }
-          end
-        end
-
-        @dependencies += classes
-        @definitions[name] = { block:, options:, classes: }
-      end
-
-      def build
-        resolve_dependencies.reverse.each do |task_class|
-          task_class.new.build
-        end
-      end
-
-      def clean
-        resolve_dependencies.each do |task_class|
-          task_class.new.clean
-        end
-      end
-
-      def refresh
-        # TODO
-      end
-
-      def resolve(queue, resolved)
-        @dependencies.each do |task|
-          if task[:klass].is_a?(Reference)
-            task[:klass].deref
-          else
-            task[:klass]
-          end => task_class
-
-          # increase priority
-          if resolved.include?(task_class)
-            resolved.delete(task_class)
-          end
-          queue << task_class
-        end
-
-        # override
-        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def self.ref(klass)
-            Object.const_get(klass)
-          end
-        RUBY
-
-        @definitions.each do |name, (_block, _options)|
-          # override
-          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-            def self.#{name}
-              @__#{name} ||= @definitions[:#{name}][:block].call
-            end
-          RUBY
-
-          define_method(name) do
-            unless instance_variable_defined?("@__#{name}")
-              instance_variable_set("@__#{name}", self.class.send(name))
-            end
-            instance_variable_get("@__#{name}")
-          end
-        end
-
-        self
-      end
-
-      private
-
-      def __resolve__
-        @__resolve__ ||= {}
-      end
-
-      def resolve_dependencies
-        queue = [self]
-        resolved = []
-
-        while queue.any?
-          resolved << task_class = queue.shift
-          task_class.resolve(queue, resolved)
-        end
-
-        resolved
-      end
-    end
-  end
+  # Main module for the Taski task framework
+  #
+  # Taski provides a framework for defining and managing task dependencies
+  # with two complementary APIs:
+  # 1. Exports API - Export instance variables as class methods (static dependencies)
+  # 2. Define API - Define lazy-evaluated values with dynamic dependency resolution
+  #
+  # Use Define API when:
+  # - Dependencies change based on runtime conditions
+  # - Environment-specific configurations
+  # - Feature flags determine which classes to use
+  # - Complex conditional logic determines dependencies
+  #
+  # Features:
+  # - Automatic dependency resolution (static and dynamic)
+  # - Static analysis of method dependencies
+  # - Runtime dependency resolution for conditional logic
+  # - Thread-safe task building
+  # - Circular dependency detection
+  # - Memory leak prevention
 end

data/sig/taski.rbs

@@ -1,4 +1,99 @@
 module Taski
   VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end
+
+  # Custom exceptions
+  class CircularDependencyError < StandardError
+  end
+
+  class TaskAnalysisError < StandardError
+  end
+
+  class TaskBuildError < StandardError
+  end
+
+  # Reference class for task references
+  class Reference
+    @klass: String
+
+    def initialize: (String klass) -> void
+    def deref: () -> Class
+    def ==: (untyped other) -> bool
+    def inspect: () -> String
+  end
+
+  # Main Task class
+  class Task
+    # Constants
+    THREAD_KEY_SUFFIX: String
+    TASKI_ANALYZING_DEFINE_KEY: Symbol
+    ANALYZED_METHODS: Array[Symbol]
+
+    # Hook methods
+    def self.method_added: (Symbol method_name) -> void
+
+    # Public API methods
+    def self.exports: (*Symbol names) -> void
+    def self.define: (Symbol name) { () -> untyped } -> void
+    def self.build: () -> void
+    def self.clean: () -> void
+    def self.reset!: () -> self
+    def self.refresh: () -> self
+    def self.resolve: (Array[untyped] queue, Array[untyped] resolved) -> self
+    def self.ref: (String | Class klass) -> (Reference | Class)
+    def self.ensure_instance_built: () -> Task
+
+    # Define API methods
+    def self.__resolve__: () -> Hash[Symbol, untyped]
+    def self.resolve_dependencies: () -> void
+
+    # Instance methods
+    def build: () -> void
+    def clean: () -> void
+
+    # Allow dynamic method definitions
+    def method_missing: (Symbol name, *untyped args) ?{ (*untyped) -> untyped } -> untyped
+    def respond_to_missing?: (Symbol name, bool include_private) -> bool
+
+    # Allow dynamic class method definitions  
+    def self.method_missing: (Symbol name, *untyped args) ?{ (*untyped) -> untyped } -> untyped
+    def self.respond_to_missing?: (Symbol name, bool include_private) -> bool
+
+    private
+
+    # Private class methods for dependency resolution
+    def self.resolve_queue: (Array[Class] queue, Array[Class] resolved) -> Array[Class]
+    def self.detect_circular_dependencies: (Array[Class] queue, Array[Class] resolved) -> void
+    def self.build_instance: (Class task_class) -> void
+
+    # Private class methods for Define API
+    def self.create_defined_method: (Symbol name) { () -> untyped } -> void
+    def self.create_ref_method_if_needed: () -> void
+    def self.method_defined_for_define?: (Symbol method_name) -> bool
+    def self.mark_method_as_defined: (Symbol method_name) -> void
+  end
+
+  # Dependency analyzer module
+  module DependencyAnalyzer
+    def self.analyze_method: (Class klass, Symbol method_name) -> Array[Class]
+
+    # Task dependency visitor for AST analysis
+    class TaskDependencyVisitor < Prism::Visitor
+      @dependencies: Array[Class]
+
+      def initialize: () -> void
+      def dependencies: () -> Array[Class]
+      def visit_call_node: (Prism::CallNode node) -> void
+
+      private
+
+      def extract_class_from_constant: (String constant_name) -> Class?
+      def safe_constantize: (String name) -> Class?
+      def extract_class_from_ref_call: (Prism::CallNode node) -> Class?
+    end
+
+    private
+
+    def self.parse_method_code: (Class klass, Symbol method_name) -> Prism::ParseResult?
+    def self.extract_dependencies_from_ast: (Prism::Node ast) -> Array[Class]
+  end
+end

metadata

@@ -1,14 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: taski
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - ahogappa
 bindir: exe
 cert_chain: []
-date: 2025-05-18 00:00:00.000000000 Z
-dependencies: []
+date: 2025-06-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
 description: Taski is a Ruby-based task runner currently under development. It allows
   you to define small, composable tasks along with the outputs they depend on. Taski
   statically resolves dependencies and executes tasks in the correct topological order,
@@ -21,11 +35,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".standard.yml"
 - LICENSE
 - README.md
 - Rakefile
+- examples/complex_example.rb
+- examples/readme_example.rb
 - lib/taski.rb
-- lib/taski/utils.rb
+- lib/taski/dependency_analyzer.rb
+- lib/taski/exceptions.rb
+- lib/taski/logger.rb
+- lib/taski/reference.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/version.rb
 - sig/taski.rbs
 homepage: https://github.com/ahogappa/taski
@@ -41,7 +66,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/taski/utils.rb

@@ -1,53 +0,0 @@
-require 'fileutils'
-require 'tmpdir'
-
-module Taski
-  class Utils < FileUtils
-    def rm
-
-    end
-
-    def rm_f
-    end
-
-    def rm_rf
-
-    end
-
-    def cp
-
-    end
-
-    def cp_r
-
-    end
-
-    def mkdir
-
-    end
-
-    def mkdir_p
-
-    end
-
-    def mktmpdir
-
-    end
-
-    def cmd(command, info = nil, ret = false)
-      puts "exec: #{info}" if info
-      puts command
-
-      if ret
-        ret = `#{command}`.chomp
-        if $?.exited?
-          ret
-        else
-          raise "Failed to execute command: #{command}"
-        end
-      else
-        system command, exception: true
-      end
-    end
-  end
-end