taski 0.3.0 → 0.4.0

data/examples/progress_demo.rb

@@ -1,166 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Taski Progress Display Demo
-#
-# This comprehensive example demonstrates all progress display features:
-# 1. Basic spinner animation with success/failure indicators
-# 2. Output capture with 5-line tail display
-# 3. Real-world build scenario with external command simulation
-# 4. TTY detection for clean file output
-#
-# Run: ruby examples/progress_demo.rb
-# Try: ruby examples/progress_demo.rb > build.log 2>&1 && cat build.log
-
-require_relative "../lib/taski"
-
-puts "🎯 Taski Progress Display Demo"
-puts "=" * 50
-
-# SECTION 1: Basic Spinner Animation
-puts "\n📍 SECTION 1: Basic Spinner & Success/Failure Indicators"
-puts "-" * 50
-
-class ConfigTask < Taski::Task
-  exports :database_url, :cache_url
-
-  def build
-    sleep 0.8
-    @database_url = "postgres://localhost/myapp"
-    @cache_url = "redis://localhost:6379"
-  end
-end
-
-class DatabaseTask < Taski::Task
-  exports :connection
-
-  def build
-    sleep 1.2
-    @connection = "Connected to #{ConfigTask.database_url}"
-  end
-end
-
-class ApplicationTask < Taski::Task
-  exports :status
-
-  def build
-    sleep 1.0
-    db = DatabaseTask.connection
-    @status = "App ready! #{db}"
-  end
-end
-
-ApplicationTask.build
-puts "🎉 Application Status: #{ApplicationTask.status}"
-
-# SECTION 2: Output Capture Demo
-puts "\n📍 SECTION 2: Output Capture with 5-Line Tail"
-puts "-" * 50
-
-class VerboseTask < Taski::Task
-  exports :result
-
-  def build
-    puts "Starting task initialization..."
-    sleep 0.3
-
-    puts "Loading configuration files..."
-    puts "Connecting to database..."
-    puts "Connection established: localhost:5432"
-    sleep 0.3
-
-    puts "Running initial checks..."
-    puts "Checking schema version..."
-    puts "Schema is up to date"
-    puts "Performing data validation..."
-    puts "Validating user records..."
-    puts "Validating product records..."
-    puts "All validations passed"
-    sleep 0.4
-
-    puts "Task completed successfully!"
-    @result = "All operations completed"
-  end
-end
-
-VerboseTask.build
-puts "📊 Verbose Task Result: #{VerboseTask.result}"
-
-# SECTION 3: Production Build Scenario
-puts "\n📍 SECTION 3: Production Build Scenario"
-puts "-" * 50
-
-class CompileTask < Taski::Task
-  exports :result
-
-  def build
-    puts "Starting compilation process..."
-    sleep 0.8
-
-    puts "Checking source files..."
-    puts "Found: main.c, utils.c, config.h"
-    sleep 0.6
-
-    puts "Running gcc compilation..."
-    puts "gcc -Wall -O2 -c main.c"
-    puts "gcc -Wall -O2 -c utils.c"
-    puts "main.c: In function 'main':"
-    puts "main.c:42: warning: unused variable 'temp'"
-    puts "utils.c: In function 'parse_config':"
-    puts "utils.c:15: warning: implicit declaration of function 'strcpy'"
-    sleep 0.8
-
-    puts "Linking objects..."
-    puts "gcc -o myapp main.o utils.o"
-    puts "Compilation successful!"
-
-    @result = "myapp binary created"
-  end
-end
-
-class TestTask < Taski::Task
-  exports :test_result
-
-  def build
-    puts "Running test suite..."
-    sleep 0.2
-
-    (1..8).each do |i|
-      puts "Test #{i}/8: #{["PASS", "PASS", "FAIL", "PASS", "PASS", "PASS", "PASS", "PASS"][i - 1]}"
-      sleep 0.4
-    end
-
-    puts "Test summary: 7/8 passed, 1 failed"
-    @test_result = "Tests completed with 1 failure"
-  end
-end
-
-CompileTask.build
-puts "📦 Compilation: #{CompileTask.result}"
-
-TestTask.build
-puts "🧪 Test Result: #{TestTask.test_result}"
-
-# SECTION 4: Error Handling Demo
-puts "\n📍 SECTION 4: Error Handling Demo"
-puts "-" * 50
-
-class FailingTask < Taski::Task
-  def build
-    puts "Attempting network connection..."
-    sleep 1.0  # Watch it spin before failing
-    puts "Connection timeout after 30 seconds"
-    puts "Retrying connection..."
-    sleep 0.5
-    raise StandardError, "Network connection failed!"
-  end
-end
-
-begin
-  FailingTask.build
-rescue Taski::TaskBuildError => e
-  puts "🛡️  Error handled gracefully: #{e.message}"
-end
-
-puts "\n✨ Demo Complete!"
-puts "Note: Rich spinner display only appears in terminals, not when output is redirected."

data/examples/tree_demo.rb

@@ -1,205 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Tree Display Demo
-#
-# This example demonstrates the tree display functionality that shows
-# task dependency relationships in a visual tree format.
-#
-# Run: ruby examples/tree_demo.rb
-
-require_relative "../lib/taski"
-
-puts "🌲 Taski Tree Display Demo"
-puts "=" * 40
-
-# Create a dependency chain for demonstration
-class Database < Taski::Task
-  exports :connection_string
-
-  def build
-    @connection_string = "postgres://localhost/myapp"
-  end
-end
-
-class Cache < Taski::Task
-  exports :redis_url
-
-  def build
-    @redis_url = "redis://localhost:6379"
-  end
-end
-
-class Config < Taski::Task
-  exports :settings
-
-  def build
-    @settings = {
-      database: Database.connection_string,
-      cache: Cache.redis_url,
-      port: 3000
-    }
-  end
-end
-
-class Logger < Taski::Task
-  exports :log_level
-
-  def build
-    @log_level = "info"
-  end
-end
-
-class WebServer < Taski::Task
-  exports :server_instance
-
-  def build
-    @server_instance = "WebServer configured with #{Config.settings[:database]} and #{Logger.log_level}"
-  end
-end
-
-class Application < Taski::Task
-  def build
-    puts "Starting application..."
-    puts "Web server: #{WebServer.server_instance}"
-    puts "Config: #{Config.settings}"
-  end
-end
-
-puts "\n📊 Application Dependency Tree:"
-puts Application.tree
-
-puts "\n🔍 Individual Component Trees:"
-puts "\nWebServer dependencies:"
-puts WebServer.tree
-
-puts "\nConfig dependencies:"
-puts Config.tree
-
-puts "\n🔧 Section-based Architecture (Dynamic Implementation Selection):"
-
-# Create database section with multiple implementation options
-class DatabaseSection < Taski::Section
-  interface :connection_string, :pool_size
-
-  def self.impl
-    if ENV["DATABASE"] == "postgres"
-      PostgresImplementation
-    elsif ENV["DATABASE"] == "mysql"
-      MysqlImplementation
-    else
-      SQLiteImplementation
-    end
-  end
-
-  class PostgresImplementation < Taski::Task
-    exports :connection_string, :pool_size
-
-    def build
-      Logger.log_level
-      @connection_string = "postgresql://localhost/production_app"
-      @pool_size = 20
-    end
-  end
-
-  class MysqlImplementation < Taski::Task
-    exports :connection_string, :pool_size
-
-    def build
-      Logger.log_level
-      @connection_string = "mysql://localhost/production_app"
-      @pool_size = 15
-    end
-  end
-
-  class SQLiteImplementation < Taski::Task
-    exports :connection_string, :pool_size
-
-    def build
-      @connection_string = "sqlite:///tmp/development.db"
-      @pool_size = 1
-    end
-  end
-end
-
-# Cache section with Redis/Memory options
-class CacheSection < Taski::Section
-  interface :cache_url
-
-  def self.impl
-    if ENV["CACHE"] == "redis"
-      RedisCache
-    else
-      MemoryCache
-    end
-  end
-
-  class RedisCache < Taski::Task
-    exports :cache_url
-    def build
-      DatabaseSection.connection_string
-      @cache_url = "redis://localhost:6379"
-    end
-  end
-
-  class MemoryCache < Taski::Task
-    exports :cache_url
-    def build
-      @cache_url = "memory://local"
-    end
-  end
-end
-
-puts "\n📋 Section Trees (Show Available Implementations):"
-puts "\nDatabaseSection.tree:"
-puts DatabaseSection.tree
-
-puts "\nCacheSection.tree:"
-puts CacheSection.tree
-
-puts "\n🔍 Individual Implementation Trees (Show Actual Dependencies):"
-puts "\nDatabaseSection::PostgresImplementation.tree:"
-puts DatabaseSection::PostgresImplementation.tree
-
-puts "\nDatabaseSection::SQLiteImplementation.tree:"
-puts DatabaseSection::SQLiteImplementation.tree
-
-puts "\nCacheSection::RedisCache.tree:"
-puts CacheSection::RedisCache.tree
-
-puts "\n🔄 Section vs Implementation Comparison:"
-puts "Section shows POSSIBLE implementations:"
-puts DatabaseSection.tree
-puts "\nBut implementation shows ACTUAL dependencies:"
-puts DatabaseSection::PostgresImplementation.tree
-
-puts "\n💡 Workflow:"
-puts "1. Use DatabaseSection.tree to see what implementations are available"
-puts "2. Use DatabaseSection::PostgresImplementation.tree to see specific dependencies"
-puts "3. Runtime selects implementation based on ENV variables"
-
-puts "\n🎨 Colored Tree Display (if TTY supports colors):"
-
-# Enable colors for demonstration
-Taski::TreeColors.enabled = true
-
-puts "\nDatabaseSection.tree (with colors):"
-puts DatabaseSection.tree(color: true)
-
-puts "\nCacheSection.tree (with colors):"
-puts CacheSection.tree(color: true)
-
-puts "\nDatabaseSection::PostgresImplementation.tree (with colors):"
-puts DatabaseSection::PostgresImplementation.tree(color: true)
-
-puts "\n🎯 Color Legend:"
-puts "#{Taski::TreeColors.section("Blue")} = Section names (dynamic selection layer)"
-puts "#{Taski::TreeColors.task("Green")} = Task names (concrete implementations)"
-puts "#{Taski::TreeColors.implementations("Yellow")} = Implementation candidates"
-puts "#{Taski::TreeColors.connector("Gray")} = Tree connectors"
-
-# Reset colors to auto-detection
-Taski::TreeColors.enabled = nil
-
-puts "\n▶️  Building Application (to verify dependencies work):"
-Application.build

data/lib/taski/dependency_analyzer.rb

@@ -1,231 +0,0 @@
-# frozen_string_literal: true
-
-require "prism"
-
-module Taski
-  module DependencyAnalyzer
-    class << self
-      def analyze_method(klass, method_name)
-        return [] unless klass.instance_methods(false).include?(method_name)
-
-        method = klass.instance_method(method_name)
-        source_location = method.source_location
-        return [] unless source_location
-
-        file_path, line_number = source_location
-        return [] unless File.exist?(file_path)
-
-        parse_source_file(file_path, line_number, klass, method_name)
-      end
-
-      private
-
-      # Parse source file and extract dependencies with proper error handling
-      # @param file_path [String] Path to source file
-      # @param line_number [Integer] Line number of method definition
-      # @param klass [Class] Class containing the method
-      # @param method_name [Symbol] Method name being analyzed
-      # @return [Array<Class>] Array of dependency classes
-      def parse_source_file(file_path, line_number, klass, method_name)
-        result = Prism.parse_file(file_path)
-        handle_parse_errors(result, file_path, klass, method_name)
-        extract_dependencies_from_node(result.value, line_number, klass, method_name)
-      rescue IOError, SystemCallError => e
-        Taski.logger.error("Failed to read source file",
-          file: file_path,
-          error: e.message,
-          method: "#{klass}##{method_name}")
-        []
-      rescue => e
-        Taski.logger.error("Failed to analyze method dependencies",
-          class: klass.name,
-          method: method_name,
-          error: e.message,
-          error_class: e.class.name)
-        []
-      end
-
-      # Handle parse errors and warnings from Prism parsing
-      # @param result [Prism::ParseResult] Parse result from Prism
-      # @param file_path [String] Path to source file
-      # @param klass [Class] Class containing the method
-      # @param method_name [Symbol] Method name being analyzed
-      # @return [Array] Empty array if errors found
-      # @raise [RuntimeError] If parse fails
-      def handle_parse_errors(result, file_path, klass, method_name)
-        unless result.success?
-          Taski.logger.error("Parse errors in source file",
-            file: file_path,
-            errors: result.errors.map(&:message),
-            method: "#{klass}##{method_name}")
-          return []
-        end
-
-        # Handle warnings if present
-        if result.warnings.any?
-          Taski.logger.warn("Parse warnings in source file",
-            file: file_path,
-            warnings: result.warnings.map(&:message),
-            method: "#{klass}##{method_name}")
-        end
-      end
-
-      # Extract dependencies from parsed AST node
-      # @param root_node [Prism::Node] Root AST node
-      # @param line_number [Integer] Line number of method definition
-      # @param klass [Class] Class containing the method
-      # @param method_name [Symbol] Method name being analyzed
-      # @return [Array<Class>] Array of unique dependency classes
-      def extract_dependencies_from_node(root_node, line_number, klass, method_name)
-        dependencies = []
-        method_node = find_method_node(root_node, method_name, line_number)
-
-        if method_node
-          visitor = TaskDependencyVisitor.new(klass)
-          visitor.visit(method_node)
-          dependencies = visitor.dependencies
-        end
-
-        dependencies.uniq
-      end
-
-      def find_method_node(node, method_name, target_line)
-        return nil unless node
-
-        case node
-        when Prism::DefNode
-          if node.name == method_name && node.location.start_line <= target_line && node.location.end_line >= target_line
-            return node
-          end
-        when Prism::ClassNode, Prism::ModuleNode
-          if node.respond_to?(:body)
-            return find_method_node(node.body, method_name, target_line)
-          end
-        when Prism::StatementsNode
-          node.body.each do |child|
-            result = find_method_node(child, method_name, target_line)
-            return result if result
-          end
-        end
-
-        # Recursively search child nodes
-        if node.respond_to?(:child_nodes)
-          node.child_nodes.each do |child|
-            result = find_method_node(child, method_name, target_line)
-            return result if result
-          end
-        end
-
-        nil
-      end
-
-      # Task dependency visitor using Prism's visitor pattern
-      class TaskDependencyVisitor < Prism::Visitor
-        attr_reader :dependencies
-
-        def initialize(context_class = nil)
-          @dependencies = []
-          @constant_cache = {}
-          @context_class = context_class
-        end
-
-        def visit_constant_read_node(node)
-          check_task_constant(node.name.to_s)
-          super
-        end
-
-        def visit_constant_path_node(node)
-          const_path = extract_constant_path(node)
-          check_task_constant(const_path) if const_path
-          super
-        end
-
-        def visit_call_node(node)
-          # Check for method calls on constants (e.g., TaskA.result)
-          case node.receiver
-          when Prism::ConstantReadNode
-            check_task_constant(node.receiver.name.to_s)
-          when Prism::ConstantPathNode
-            const_path = extract_constant_path(node.receiver)
-            check_task_constant(const_path) if const_path
-          end
-          super
-        end
-
-        private
-
-        def check_task_constant(const_name)
-          return unless const_name
-
-          # Use caching to avoid repeated constant resolution
-          cached_result = @constant_cache[const_name]
-          return cached_result if cached_result == false # Cached negative result
-          return @dependencies << cached_result if cached_result # Cached positive result
-
-          begin
-            resolved_class = nil
-
-            # 1. Try absolute reference first (existing logic)
-            if Object.const_defined?(const_name)
-              resolved_class = Object.const_get(const_name)
-            # 2. Try relative reference within namespace context
-            elsif @context_class
-              resolved_class = resolve_relative_constant(const_name)
-            end
-
-            if resolved_class&.is_a?(Class) && (resolved_class < Taski::Task || resolved_class < Taski::Section)
-              @constant_cache[const_name] = resolved_class
-              @dependencies << resolved_class
-            else
-              @constant_cache[const_name] = false
-            end
-          rescue NameError, ArgumentError
-            @constant_cache[const_name] = false
-          end
-        end
-
-        def resolve_relative_constant(const_name)
-          return nil unless @context_class
-
-          # Get the namespace from the context class
-          namespace = get_namespace_from_class(@context_class)
-          return nil unless namespace
-
-          # Try to resolve the constant within the namespace
-          full_const_name = "#{namespace}::#{const_name}"
-          Object.const_get(full_const_name) if Object.const_defined?(full_const_name)
-        rescue NameError, ArgumentError
-          nil
-        end
-
-        def get_namespace_from_class(klass)
-          # Extract namespace from class name (e.g., "A::AB" -> "A")
-          class_name = klass.name
-          return nil unless class_name&.include?("::")
-
-          # Split by "::" and take all but the last part
-          parts = class_name.split("::")
-          return nil if parts.length <= 1  # No namespace
-
-          parts[0..-2].join("::")
-        end
-
-        def extract_constant_path(node)
-          case node
-          when Prism::ConstantReadNode
-            node.name.to_s
-          when Prism::ConstantPathNode
-            parent_path = extract_constant_path(node.parent) if node.parent
-            child_name = node.name.to_s
-
-            if parent_path && child_name
-              "#{parent_path}::#{child_name}"
-            else
-              child_name
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/taski/exceptions.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Taski
-  # Custom exceptions for Taski framework
-
-  # Raised when circular dependencies are detected between tasks
-  class CircularDependencyError < StandardError; end
-
-  # Raised when task analysis fails (e.g., constant resolution errors)
-  class TaskAnalysisError < StandardError; end
-
-  # Raised when task building fails during execution
-  class TaskBuildError < StandardError; end
-
-  # Raised when section implementation method is missing
-  class SectionImplementationError < StandardError; end
-end