tng 0.2.1

data/lib/tng/services/direct_generation.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+require_relative "extract_methods"
+
+module Tng
+  module Services
+    class DirectGeneration
+      include ExtractMethods
+
+      def initialize(pastel, testng, http_client, params, show_post_generation_menu_proc)
+        @pastel = pastel
+        @testng = testng
+        @http_client = http_client
+        @params = params
+        @show_post_generation_menu = show_post_generation_menu_proc
+      end
+
+      def run
+        type = normalize_type(@params[:type])
+        file_name = @params[:file]
+        method_name = @params[:method]
+
+        unless type && file_name && method_name
+          puts @pastel.red("❌ All parameters are required for direct generation: --type, --file, --method")
+          puts @pastel.yellow("Usage: bundle exec tng --type=controller --file=users --method=index")
+          puts @pastel.yellow("Shortcuts: bundle exec tng -t=c -f=users -m=index")
+          return
+        end
+
+        unless %w[controller model service other].include?(type)
+          puts @pastel.red("❌ Invalid type: #{@params[:type]}")
+          puts @pastel.yellow("Supported types: controller, model, service, other")
+          return
+        end
+
+        case type
+        when "controller"
+          run_controller_method_generation(file_name, method_name)
+        when "model"
+          run_model_method_generation(file_name, method_name)
+        when "service"
+          run_service_method_generation(file_name, method_name)
+        when "other"
+          run_other_method_generation(file_name, method_name)
+        end
+      end
+
+      def normalize_type(type_param)
+        case type_param&.downcase
+        when "c", "controller"
+          "controller"
+        when "m", "mo", "model"
+          "model"
+        when "s", "se", "service"
+          "service"
+        when "o", "other"
+          "other"
+        else
+          type_param&.downcase
+        end
+      end
+
+      def run_controller_method_generation(file_name, method_name)
+        controllers = Tng::Analyzers::Controller.files_in_dir("app/controllers").map do |file|
+          relative_path = file[:path].gsub(%r{^.*app/controllers/}, "").gsub(".rb", "")
+          namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+
+          {
+            name: namespaced_name,
+            path: file[:path]
+          }
+        end
+
+        controller = find_matching_controller(controllers, file_name)
+
+        unless controller
+          puts @pastel.red("❌ Controller not found: #{file_name}")
+          puts @pastel.yellow("Available controllers:")
+          controllers.first(5).each do |ctrl|
+            puts @pastel.dim("  - #{ctrl[:name]}")
+          end
+          puts @pastel.dim("  ... and #{controllers.length - 5} more") if controllers.length > 5
+          return
+        end
+
+        methods = extract_controller_methods(controller)
+
+        if methods.empty?
+          puts @pastel.yellow("⚠️  No methods found in #{controller[:name]}")
+          return
+        end
+
+        method_info = methods.find { |method| method[:name].downcase == method_name.downcase }
+
+        unless method_info
+          puts @pastel.red("❌ Method '#{method_name}' not found in #{controller[:name]}")
+          puts @pastel.yellow("Available methods:")
+          methods.first(10).each do |method|
+            puts @pastel.dim("  - #{method[:name]}")
+          end
+          puts @pastel.dim("  ... and #{methods.length - 10} more") if methods.length > 10
+          return
+        end
+
+        puts @pastel.bright_white("🎯 Generating test for #{controller[:name]}##{method_info[:name]}...")
+
+        result = Tng::Services::TestGenerator.new(@http_client).run_for_controller_method(controller, method_info)
+
+        if result && result[:file_path]
+          @show_post_generation_menu.call(result)
+        else
+          puts @pastel.red("❌ Failed to generate test")
+        end
+      end
+
+      def find_matching_controller(controllers, file_name)
+        controllers.find do |controller|
+          controller[:name].downcase == file_name.downcase ||
+            controller[:name].split("::").last.downcase == file_name.downcase ||
+            File.basename(controller[:path], ".rb").downcase == file_name.downcase ||
+            File.basename(controller[:path], ".rb").gsub("_controller", "").downcase == file_name.downcase ||
+            File.basename(controller[:path], ".rb").downcase == "#{file_name}_controller".downcase
+        end
+      end
+
+      def run_model_method_generation(file_name, method_name)
+        models = Tng::Analyzers::Model.files_in_dir("app/models").map do |file|
+          relative_path = file[:path].gsub(%r{^.*app/models/}, "").gsub(".rb", "")
+          namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+
+          {
+            name: namespaced_name,
+            path: file[:path]
+          }
+        end
+
+        model = find_matching_model(models, file_name)
+
+        unless model
+          puts @pastel.red("❌ Model not found: #{file_name}")
+          puts @pastel.yellow("Available models:")
+          models.first(5).each do |mdl|
+            puts @pastel.dim("  - #{mdl[:name]}")
+          end
+          puts @pastel.dim("  ... and #{models.length - 5} more") if models.length > 5
+          return
+        end
+
+        methods = extract_model_methods(model)
+
+        if methods.empty?
+          puts @pastel.yellow("⚠️  No methods found in #{model[:name]}")
+          return
+        end
+
+        method_info = methods.find { |method| method[:name].downcase == method_name.downcase }
+
+        unless method_info
+          puts @pastel.red("❌ Method '#{method_name}' not found in #{model[:name]}")
+          puts @pastel.yellow("Available methods:")
+          methods.first(10).each do |method|
+            puts @pastel.dim("  - #{method[:name]}")
+          end
+          puts @pastel.dim("  ... and #{methods.length - 10} more") if methods.length > 10
+          return
+        end
+
+        puts @pastel.bright_white("🎯 Generating test for #{model[:name]}##{method_info[:name]}...")
+
+        result = Tng::Services::TestGenerator.new(@http_client).run_for_model_method(model, method_info)
+
+        if result && result[:file_path]
+          @show_post_generation_menu.call(result)
+        else
+          puts @pastel.red("❌ Failed to generate test")
+        end
+      end
+
+      def find_matching_model(models, file_name)
+        models.find do |model|
+          model[:name].downcase == file_name.downcase ||
+            model[:name].split("::").last.downcase == file_name.downcase ||
+            File.basename(model[:path], ".rb").downcase == file_name.downcase
+        end
+      end
+
+      def run_service_method_generation(file_name, method_name)
+        services = Tng::Analyzers::Service.files_in_dir.map do |file|
+          relative_path = file[:path].gsub(%r{^.*app/services?/}, "").gsub(".rb", "")
+          namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+
+          {
+            name: namespaced_name,
+            path: file[:path]
+          }
+        end
+
+        service = find_matching_service(services, file_name)
+
+        unless service
+          puts @pastel.red("❌ Service not found: #{file_name}")
+          puts @pastel.yellow("Available services:")
+          services.first(5).each do |svc|
+            puts @pastel.dim("  - #{svc[:name]}")
+          end
+          puts @pastel.dim("  ... and #{services.length - 5} more") if services.length > 5
+          return
+        end
+
+        methods = extract_service_methods(service)
+
+        if methods.empty?
+          puts @pastel.yellow("⚠️  No methods found in #{service[:name]}")
+          return
+        end
+
+        method_info = methods.find { |method| method[:name].downcase == method_name.downcase }
+
+        unless method_info
+          puts @pastel.red("❌ Method '#{method_name}' not found in #{service[:name]}")
+          puts @pastel.yellow("Available methods:")
+          methods.first(10).each do |method|
+            puts @pastel.dim("  - #{method[:name]}")
+          end
+          puts @pastel.dim("  ... and #{methods.length - 10} more") if methods.length > 10
+          return
+        end
+
+        puts @pastel.bright_white("🎯 Generating test for #{service[:name]}##{method_info[:name]}...")
+
+        result = Tng::Services::TestGenerator.new(@http_client).run_for_service_method(service, method_info)
+
+        if result && result[:file_path]
+          @show_post_generation_menu.call(result)
+        else
+          puts @pastel.red("❌ Failed to generate test")
+        end
+      end
+
+      def find_matching_service(services, file_name)
+        services.find do |service|
+          service[:name].downcase == file_name.downcase ||
+            service[:name].split("::").last.downcase == file_name.downcase ||
+            File.basename(service[:path], ".rb").downcase == file_name.downcase
+        end
+      end
+
+      def run_other_method_generation(file_name, method_name)
+        other_files = Tng::Analyzers::Other.files_in_dir.map do |file|
+          relative_path = file[:relative_path].gsub(".rb", "")
+          namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+
+          {
+            name: namespaced_name,
+            path: file[:path],
+            type: file[:type]
+          }
+        end
+
+        other_file = find_matching_other_file(other_files, file_name)
+
+        unless other_file
+          puts @pastel.red("❌ Other file not found: #{file_name}")
+          puts @pastel.yellow("Available other files:")
+          other_files.first(5).each do |file|
+            puts @pastel.dim("  - #{file[:name]}")
+          end
+          puts @pastel.dim("  ... and #{other_files.length - 5} more") if other_files.length > 5
+          return
+        end
+
+        methods = extract_other_methods(other_file)
+
+        if methods.empty?
+          puts @pastel.yellow("⚠️  No methods found in #{other_file[:name]}")
+          return
+        end
+
+        method_info = methods.find { |method| method[:name].downcase == method_name.downcase }
+
+        unless method_info
+          puts @pastel.red("❌ Method '#{method_name}' not found in #{other_file[:name]}")
+          puts @pastel.yellow("Available methods:")
+          methods.first(10).each do |method|
+            puts @pastel.dim("  - #{method[:name]}")
+          end
+          puts @pastel.dim("  ... and #{methods.length - 10} more") if methods.length > 10
+          return
+        end
+
+        puts @pastel.bright_white("🎯 Generating test for #{other_file[:name]}##{method_info[:name]}...")
+
+        result = Tng::Services::TestGenerator.new(@http_client).run_for_other_method(other_file, method_info)
+
+        if result && result[:file_path]
+          @show_post_generation_menu.call(result)
+        else
+          puts @pastel.red("❌ Failed to generate test")
+        end
+      end
+
+      def find_matching_other_file(other_files, file_name)
+        other_files.find do |file|
+          file[:name].downcase == file_name.downcase ||
+            file[:name].split("::").last.downcase == file_name.downcase ||
+            File.basename(file[:path], ".rb").downcase == file_name.downcase ||
+            normalize_other_file_path(file[:path]).downcase == file_name.downcase
+        end
+      end
+
+      def normalize_other_file_path(file_path)
+        Tng::Analyzers::Other::OTHER_DIRECTORIES.each do |dir|
+          pattern = %r{^.*/#{Regexp.escape(dir)}/}
+          return file_path.gsub(pattern, "").gsub(".rb", "") if file_path.match?(pattern)
+        end
+        file_path # fallback if no match
+      end
+    end
+  end
+end

data/lib/tng/services/extract_methods.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Tng
+  module Services
+    module ExtractMethods
+      def extract_controller_methods(controller)
+        methods = Tng::Analyzers::Controller.methods_for_controller(controller[:name])
+        Array(methods)
+      rescue StandardError => e
+        puts center_text(@pastel.decorate("#{Tng::UI::Theme.icon(:error)} Error analyzing controller: #{e.message}", Tng::UI::Theme.color(:error)))
+        []
+      end
+
+      def extract_model_methods(model)
+        methods = Tng::Analyzers::Model.methods_for_model(model[:name])
+        Array(methods)
+      rescue StandardError => e
+        puts center_text(@pastel.decorate("#{Tng::UI::Theme.icon(:error)} Error analyzing model: #{e.message}", Tng::UI::Theme.color(:error)))
+        []
+      end
+
+      def extract_service_methods(service)
+        methods = Tng::Analyzers::Service.methods_for_service(service[:name])
+        Array(methods)
+      rescue StandardError => e
+        puts center_text(@pastel.decorate("#{Tng::UI::Theme.icon(:error)} Error analyzing service: #{e.message}", Tng::UI::Theme.color(:error)))
+        []
+      end
+
+      def extract_other_methods(other_file)
+        methods = Tng::Analyzers::Other.methods_for_other(other_file[:name], other_file[:path])
+        Array(methods)
+      rescue StandardError => e
+        puts center_text(@pastel.decorate("#{Tng::UI::Theme.icon(:error)} Error analyzing file: #{e.message}", Tng::UI::Theme.color(:error)))
+        []
+      end
+    end
+  end
+end

data/lib/tng/services/test_generator.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "tng/utils"
+require "tng/services/user_app_config"
+require "tng/ui/theme"
+require "pastel"
+
+module Tng
+  module Services
+    class TestGenerator
+      GENERATE_TESTS_PATH = "cli/tng_rails/contents/generate_tests"
+      CONTENT_RESPONSES_PATH = "cli/tng_rails/content_responses"
+      POLL_INTERVAL_SECONDS = 5 # Poll every 5 seconds
+      MAX_POLL_DURATION_SECONDS = 360 # 6 minutes total
+
+      def initialize(http_client)
+        @http_client = http_client
+        @machine_info = Tng.machine_info
+        @pastel = Pastel.new
+      end
+
+      def run_for_controller_method(controller, method_info)
+        start_time = Time.now
+
+        response = Tng.send_request_for_controller(
+          controller[:name],
+          controller[:path],
+          method_info[:name],
+          Tng::Utils.fixture_content,
+          Tng::Services::UserAppConfig.config_with_source,
+          Tng::Services::UserAppConfig.base_url,
+          Tng::Services::UserAppConfig.api_key
+        )
+
+        job_data = JSON.parse(response.body)
+        job_id = job_data["job_id"]
+
+        return unless job_id
+
+        result = poll_for_completion(job_id)
+
+        return unless result
+
+        end_time = Time.now
+        generation_time = end_time - start_time
+
+        file_result = Tng::Utils.save_test_file(result.to_json)
+        return unless file_result
+
+        file_result.merge(generation_time: generation_time)
+      end
+
+      def run_for_model_method(model, method_info)
+        start_time = Time.now
+
+        response = Tng.send_request_for_model(
+          model[:name],
+          model[:path],
+          method_info[:name],
+          Tng::Utils.fixture_content,
+          Tng::Services::UserAppConfig.config_with_source,
+          Tng::Services::UserAppConfig.base_url,
+          Tng::Services::UserAppConfig.api_key
+        )
+
+        job_data = JSON.parse(response.body)
+        job_id = job_data["job_id"]
+
+        return unless job_id
+
+        result = poll_for_completion(job_id)
+
+        return unless result
+
+        end_time = Time.now
+        generation_time = end_time - start_time
+
+        file_result = Tng::Utils.save_test_file(result.to_json)
+        return unless file_result
+
+        file_result.merge(generation_time: generation_time)
+      end
+
+      def run_for_service_method(service, method_info)
+        start_time = Time.now
+
+        response = Tng.send_request_for_service(
+          service[:name],
+          service[:path],
+          method_info[:name],
+          Tng::Utils.fixture_content,
+          Tng::Services::UserAppConfig.config_with_source,
+          Tng::Services::UserAppConfig.base_url,
+          Tng::Services::UserAppConfig.api_key
+        )
+
+        job_data = JSON.parse(response.body)
+        job_id = job_data["job_id"]
+
+        return unless job_id
+
+        result = poll_for_completion(job_id)
+
+        return unless result
+
+        end_time = Time.now
+        generation_time = end_time - start_time
+
+        file_result = Tng::Utils.save_test_file(result.to_json)
+        return unless file_result
+
+        file_result.merge(generation_time: generation_time)
+      end
+
+      def run_for_other_method(other_file, method_info)
+        start_time = Time.now
+
+        response = Tng.send_request_for_other(
+          other_file[:name] || File.basename(other_file[:path], ".rb"),
+          other_file[:path],
+          method_info[:name],
+          Tng::Utils.fixture_content,
+          Tng::Services::UserAppConfig.config_with_source,
+          Tng::Services::UserAppConfig.base_url,
+          Tng::Services::UserAppConfig.api_key
+        )
+
+        job_data = JSON.parse(response.body)
+        job_id = job_data["job_id"]
+
+        return unless job_id
+
+        result = poll_for_completion(job_id)
+
+        return unless result
+
+        end_time = Time.now
+        generation_time = end_time - start_time
+
+        file_result = Tng::Utils.save_test_file(result.to_json)
+        return unless file_result
+
+        file_result.merge(generation_time: generation_time)
+      end
+
+      private
+
+      def send_request_and_save_test(payload)
+        job_id = submit_async_job(payload)
+        return unless job_id
+
+        result = poll_for_completion(job_id)
+        return unless result
+
+        Tng::Utils.save_test_file(result.to_json)
+      rescue StandardError => e
+        debug_log("Async request failed: #{e.message}") if debug_enabled?
+        puts "❌ Failed to generate test: #{e.message}"
+        nil
+      end
+
+      def submit_async_job(payload)
+        marshaled = Marshal.dump(payload)
+        compressed = Zlib::Deflate.deflate(marshaled)
+        response = @http_client.post_binary(GENERATE_TESTS_PATH, compressed)
+
+        if response.is_a?(HTTPX::ErrorResponse)
+          debug_log("Processing test failed") if debug_enabled?
+          puts "❌ Failed to submit test generation job: #{response.error&.message}"
+          return
+        end
+
+        job_data = JSON.parse(response.body)
+        job_id = job_data["job_id"]
+
+        debug_log("Processing test with id: #{job_id}") if debug_enabled?
+
+        job_id
+      rescue JSON::ParserError => e
+        debug_log("Failed to parse API response: #{e.message}") if debug_enabled?
+        puts "❌ Failed to parse API response. Please retry."
+      end
+
+      def poll_for_completion(job_id)
+        start_time = Time.current
+
+        rocket_icon = Tng::UI::Theme.icon(:rocket)
+        success_color = Tng::UI::Theme.color(:success)
+        primary_color = Tng::UI::Theme.color(:primary)
+        muted_color = Tng::UI::Theme.color(:muted)
+
+        complete_char = @pastel.decorate("▓", success_color)
+        incomplete_char = @pastel.decorate("░", muted_color)
+        head_char = @pastel.decorate("▶", success_color)
+
+        progress_bar = TTY::ProgressBar.new(
+          "#{rocket_icon} #{@pastel.decorate("Generating tests",
+                                             primary_color)} #{@pastel.decorate("[:bar]",
+                                                                                :white)} #{@pastel.decorate(":status",
+                                                                                                            muted_color)} #{@pastel.decorate(
+                                                                                                              "(:elapsed)", muted_color
+                                                                                                            )}",
+          total: nil,
+          complete: complete_char,
+          incomplete: incomplete_char,
+          head: head_char,
+          width: 40,
+          clear: true,
+          frequency: 10,  # Update 10 times per second for smooth animation
+          interval: 1     # Show elapsed time updates every second
+        )
+
+        loop do
+          seconds_elapsed = (Time.current - start_time).to_i
+
+          if seconds_elapsed > MAX_POLL_DURATION_SECONDS
+            progress_bar.finish
+            puts "❌ Test generation timed out after #{MAX_POLL_DURATION_SECONDS} seconds (6 minutes)"
+            return
+          end
+
+          status_text = case seconds_elapsed
+                        when 0..15 then "initializing..."
+                        when 16..45 then "analyzing code structure..."
+                        when 46..90 then "generating test cases..."
+                        when 91..150 then "optimizing test logic..."
+                        when 151..210 then "refining assertions..."
+                        when 211..270 then "formatting output..."
+                        when 271..330 then "finalizing tests..."
+                        else "completing generation..."
+                        end
+          progress_bar.advance(1, status: status_text)
+
+          sleep(POLL_INTERVAL_SECONDS)
+
+          status_response = @http_client.get("#{CONTENT_RESPONSES_PATH}/#{job_id}")
+
+          if status_response.is_a?(HTTPX::ErrorResponse)
+            debug_log("Status check failed: #{status_response.error&.message}") if debug_enabled?
+            next # Continue polling on network errors
+          end
+
+          begin
+            status_data = JSON.parse(status_response.body.to_s)
+            status = status_data["status"]
+
+            case status
+            when "completed"
+              debug_log("Test generation completed!") if debug_enabled?
+              progress_bar.finish
+              success_icon = Tng::UI::Theme.icon(:success)
+              success_color = Tng::UI::Theme.color(:success)
+              puts "#{success_icon} #{@pastel.decorate("Test generation completed!", success_color)}"
+              return status_data["result"]
+            when "failed"
+              debug_log("Test generation failed: #{status_data["error"]}") if debug_enabled?
+              progress_bar.finish
+              error_icon = Tng::UI::Theme.icon(:error)
+              error_color = Tng::UI::Theme.color(:error)
+              puts "#{error_icon} #{@pastel.decorate("Test generation failed:",
+                                                     error_color)} #{status_data["error"] || "Unknown error"}"
+              return
+            when "pending", "processing"
+              # Progress bar updates smoothly above
+              next
+            else
+              debug_log("Unknown test generation status: #{status}") if debug_enabled?
+              next
+            end
+          rescue JSON::ParserError => e
+            debug_log("Failed to parse response status: #{e.message}") if debug_enabled?
+            next
+          end
+        end
+      end
+
+      def debug_enabled?
+        ENV["DEBUG"] == "1"
+      end
+
+      def debug_log(message)
+        puts "-> DEBUG [TestGenerator]: #{message}"
+      end
+    end
+  end
+end