taski 0.1.0 → 0.2.0

data/lib/taski.rb

@@ -1,155 +1,40 @@
 # frozen_string_literal: true
 
-require_relative "taski/version"
-
-module Taski
-  class Reference
-    def initialize(klass)
-      @klass = klass
-    end
-
-    def deref
-      Object.const_get(@klass)
-    end
-
-    def inspect
-      "&#{@klass}"
-    end
-  end
-
-  class Task
-    def self.__resolve__
-      @__resolve__ ||= {}
-    end
-
-    def self.ref(klass)
-      ref = Reference.new(klass)
-      throw :unresolve, ref
-    end
-
-    def self.definition(name, block, **options)
-      @dependencies ||= []
-      @definitions ||= {}
-
-      self.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        def self.#{name}
-          __resolve__[__callee__] ||= false
-          if __resolve__[__callee__]
-            # already resolved
-          else
-            __resolve__[__callee__] = true
-            throw :unresolve, [self, __callee__]
-          end
-        end
-      RUBY
-
-      classes = []
-      loop do
-        klass, task = catch(:unresolve) 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 self.build
-      resolve_dependences.reverse.each do |task_class|
-        task_class.new.build
-      end
-    end
+require 'set'
+require 'monitor'
 
-    def self.clean
-      resolve_dependences.each do |task_class|
-        task_class.new.clean
-      end
-    end
-
-    def exec_command(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
-
-    def self.refresh
-      # TODO
-    end
-
-    private
-
-    def self.resolve(queue, resolved)
-      @dependencies.each do |task|
-        if task[:klass].is_a?(Reference)
-          task_class = task[:klass].deref
-        end
-
-        # increase priority
-        if resolved.include?(task[:klass])
-          resolved.delete(task[:klass])
-        end
-        queue << task[:klass]
-      end
-
-      # override
-      self.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        def self.ref(klass)
-          Object.const_get(klass)
-        end
-      RUBY
-
-      @definitions.each do |name, (block, options)|
-        # override
-        self.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def self.#{name}
-            @__#{name} ||= @definitions[:#{name}][:block].call
-          end
-        RUBY
-
-        self.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
-
-    def self.resolve_dependences
-      queue = [self]
-      resolved = []
+# Load core components
+require_relative "taski/version"
+require_relative "taski/exceptions"
+require_relative "taski/reference"
+require_relative "taski/dependency_analyzer"
 
-      while queue.any?
-        resolved << task_class = queue.shift
-        task_class.resolve(queue, resolved)
-      end
+# 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"
 
-      resolved
-    end
-  end
-end
+module Taski
+  # 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,62 @@
 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, Proc block, **untyped options) -> 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 klass) -> Reference
+    def self.ensure_instance_built: () -> Task
+
+    # 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
+  end
+
+  # Dependency analyzer module
+  module DependencyAnalyzer
+    def self.analyze_method: (Class klass, Symbol method_name) -> Array[Class]
+  end
+end

metadata

@@ -1,14 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: taski
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - ahogappa
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+date: 2025-06-15 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,9 +35,21 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - README.md
 - Rakefile
+- Steepfile
+- examples/complex_example.rb
+- examples/readme_example.rb
 - lib/taski.rb
+- lib/taski/dependency_analyzer.rb
+- lib/taski/exceptions.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
@@ -46,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.2
 specification_version: 4
 summary: A simple yet powerful Ruby task runner with static dependency resolution
   (in development).